# I'm working in a Python Virtual Environment, install the following packages into yours.

#!pip install missingno
#!pip install -U scikit-learn
#!pip install scipy
#!pip install seaborn
#!pip install pandas
#!pip install matplotlib
#!pip install statsmodels
#!pip install fancyimpute
#!pip install nbconvert[qtpdf]


# Specifically for Jupyter Notebooks

# !python3 -m pip install cite2c
# !python3 -m cite2c.install

# # Importing the necessary packages
import pandas as pd
import matplotlib.pyplot as plt
# from scipy import stats
from fancyimpute import KNN
from fancyimpute import IterativeImputer
import statsmodels.api as sm
import numpy as np
import seaborn as sns
from statsmodels.formula.api import ols
from sklearn.preprocessing import OrdinalEncoder
from statsmodels.multivariate.manova import MANOVA
from scipy.stats import skew

# The table of indicators
the_metrics = [
    ['Food Nutrient Adequacy', 'Food Nutrient Adequacy', 'Food Nutrient Adequacy', 'Food Nutrient Adequacy', 'Food Nutrient Adequacy', 'Ecosystem Stability', 'Ecosystem Stability', 'Ecosystem Stability', 'Ecosystem Stability', 'Ecosystem Stability', 'Food Affordability & Availability', 'Food Affordability & Availability', 'Food Affordability & Availability', 'Food Affordability & Availability', 'Socialcultural Wellbeing', 'Socialcultural Wellbeing', 'Socialcultural Wellbeing', 'Socialcultural Wellbeing', 'Resilience', 'Resilience', 'Food Safety', 'Food Safety', 'Waste & Loss Reduction'],
    ['Non-Staple Food Energy', 'Shannon Diversity', 'Modified Functional Attribute Diversity', 'Nutrient Density Score', 'Population Share With Adequate Nutrients', 'Ecosystem Status', 'GHG Emissions', 'Net FreshWater Withdrawals', 'Energy Use', 'Land Use', 'Income Equality', 'Poverty Index', 'GFSI Food Availability Score', 'Food Affordability', 'Animal Health & Welfare', 'Community Rights', ' Child Labor', 'Gender Equity', 'Food Production Diversity', 'ND-GAIN Country Index', 'GFSI Safety Score', 'Foodborne Disease Burden', 'Pre & Post-Consumer Food Loss'],
    ['Nutrients From Non-Staple Food', 'Nutrient Diversity in The Food System', 'Nutrient Diversity in The Food System', 'Nutrient Diversity in The Food System', 'Proportion of Population With Adequate Nutrients', 'Ecosystem Status', 'Eco-Efficiency', 'Eco-Efficiency', 'Eco-Efficiency', 'Eco-Efficiency', 'Food Availability & Affordability', 'Food Availability & Affordability', 'Food Availability & Affordability', 'Food Availability & Affordability', 'Gender Equality', 'Extent of Child Labor', 'Respect for Community Rights', 'Animal Health & Welfare', "Nation's Vulnerability to Climate Change", "Shares of Agricultural Food Production in The Country", "Food Borne Disease Burden", "GFSI Food Safety", "FAO"]
]

sources = [['FAOs Food Balance Sheets'], ['FAOs Food Balance Sheets'], ['FAOs Food Balance Sheets'],['FAOs Food Balance Sheets'], ['FAOSTATS'], ['Yale Center for Environmental Law and Policy'], ['United Nations Framework Convention on Climate Change'], ['Data Collections, NASA'], ['Data Collections, NASA'], ['Data Collections, NASA'], ['Global Food Security Index (GFSI)'], ['Global Food Security Index (GFSI)'], ['United Nations, 2021'], ['United Nations, 2021'], ['Global Gender Gap Report 2020'], ['ILO, 2020'], ['Environmental Democracy Index'], ['Not Measured (Insufficient Data)'], ["Notre Dame Global Adaptation Initiative"], ["FAOSTAT"], ["World Health Organisation (WHO)"], ["Global Food Security Index (GFSI)"], ["FAO"]]


the_table = pd.DataFrame(sources,
                         index= the_metrics,
                         columns = ["Sources"]
                        )

the_table.index = the_table.index.rename(['The Metric', 'Indicators', 'What They Measure'])

the_table.style

#the_table.to_csv('The Metrics.csv')

# Building a data scaler for some of the indicators

def scaler(df, column) :
    """Scales the dataset to a 0-100 scale"""

    median_values = df[column].median()

    scaled_values = list()

    for i, val in df[[column]].iterrows():
        scaler = 100 * np.exp(np.log(0.5) * (val/median_values))

        scaled_values.append(scaler.values[0])

    df["Scaled Values"] = scaled_values

    return df

# Building the sampling function that will be used in all datasets

# Setting the seed for sampling function

np.random.seed(10)

# 1. Loading the 'Country_Groups' Data Set
size_of_economy = pd.read_csv('Country_Groups.csv', sep = ",", \
                  header = 0, usecols = ["Country","Income group", \
                  "Region"]).set_index('Country')

display(size_of_economy.head())

# 2. Displaying the count of countries in each country group.

counts = pd.DataFrame(size_of_economy['Income group'].value_counts())

counts.loc['Total'] = counts['count'].sum()

display(counts)

# 3. Loading the Dietary Intake Dataset

dietary_intake = pd.read_csv("Daily_Energy_Intake.csv", 
                		sep= ',', 
                		header= None,
                        skiprows= [0],
                        names= ['Country', 'Food', 'Value'],
                        usecols= [0, 1, 2],
                            )

display(dietary_intake.head(10))

# 4. Transposing the 2nd column to work with the data easily.
dietary_intake_transposed = dietary_intake.pivot_table(
	index= 'Country',
    columns= 'Food',
    values = 'Value'
)
    
display(dietary_intake_transposed.head())

# 5. Checking the data type and Column Names

display(dietary_intake_transposed.info())

display(dietary_intake_transposed.columns)

<class 'pandas.core.frame.DataFrame'>
Index: 186 entries, Afghanistan to Zimbabwe
Data columns (total 97 columns):
 #   Column                           Non-Null Count  Dtype  
---  ------                           --------------  -----  
 0   Apples and products              186 non-null    float64
 1   Aquatic Animals, Others          167 non-null    float64
 2   Aquatic Plants                   179 non-null    float64
 3   Bananas                          182 non-null    float64
 4   Barley and products              179 non-null    float64
 5   Beans                            179 non-null    float64
 6   Beer                             184 non-null    float64
 7   Beverages, Alcoholic             185 non-null    float64
 8   Beverages, Fermented             179 non-null    float64
 9   Bovine Meat                      186 non-null    float64
 10  Butter, Ghee                     186 non-null    float64
 11  Cassava and products             147 non-null    float64
 12  Cephalopods                      183 non-null    float64
 13  Cereals, Other                   186 non-null    float64
 14  Citrus, Other                    181 non-null    float64
 15  Cloves                           169 non-null    float64
 16  Cocoa Beans and products         186 non-null    float64
 17  Coconut Oil                      159 non-null    float64
 18  Coconuts - Incl Copra            185 non-null    float64
 19  Coffee and products              186 non-null    float64
 20  Cottonseed                       12 non-null     float64
 21  Cottonseed Oil                   131 non-null    float64
 22  Cream                            171 non-null    float64
 23  Crustaceans                      184 non-null    float64
 24  Dates                            177 non-null    float64
 25  Demersal Fish                    186 non-null    float64
 26  Eggs                             186 non-null    float64
 27  Fats, Animals, Raw               186 non-null    float64
 28  Fish, Body Oil                   169 non-null    float64
 29  Fish, Liver Oil                  160 non-null    float64
 30  Freshwater Fish                  186 non-null    float64
 31  Fruits, other                    186 non-null    float64
 32  Grapefruit and products          181 non-null    float64
 33  Grapes and products (excl wine)  185 non-null    float64
 34  Groundnut Oil                    178 non-null    float64
 35  Groundnuts                       186 non-null    float64
 36  Honey                            185 non-null    float64
 37  Infant food                      176 non-null    float64
 38  Lemons, Limes and products       184 non-null    float64
 39  Maize Germ Oil                   175 non-null    float64
 40  Maize and products               181 non-null    float64
 41  Marine Fish, Other               184 non-null    float64
 42  Meat, Aquatic Mammals            3 non-null      float64
 43  Meat, Other                      184 non-null    float64
 44  Milk - Excluding Butter          186 non-null    float64
 45  Millet and products              82 non-null     float64
 46  Miscellaneous                    175 non-null    float64
 47  Molluscs, Other                  184 non-null    float64
 48  Mutton & Goat Meat               186 non-null    float64
 49  Nuts and products                186 non-null    float64
 50  Oats                             183 non-null    float64
 51  Offals, Edible                   186 non-null    float64
 52  Oilcrops Oil, Other              186 non-null    float64
 53  Oilcrops, Other                  158 non-null    float64
 54  Olive Oil                        185 non-null    float64
 55  Olives (including preserved)     184 non-null    float64
 56  Onions                           182 non-null    float64
 57  Oranges, Mandarines              186 non-null    float64
 58  Palm Oil                         144 non-null    float64
 59  Palm kernels                     1 non-null      float64
 60  Palmkernel Oil                   121 non-null    float64
 61  Peas                             175 non-null    float64
 62  Pelagic Fish                     186 non-null    float64
 63  Pepper                           185 non-null    float64
 64  Pigmeat                          184 non-null    float64
 65  Pimento                          183 non-null    float64
 66  Pineapples and products          186 non-null    float64
 67  Plantains                        152 non-null    float64
 68  Potatoes and products            186 non-null    float64
 69  Poultry Meat                     186 non-null    float64
 70  Pulses, Other and products       186 non-null    float64
 71  Rape and Mustard Oil             150 non-null    float64
 72  Rape and Mustardseed             182 non-null    float64
 73  Rice and products                186 non-null    float64
 74  Ricebran Oil                     28 non-null     float64
 75  Roots, Other                     180 non-null    float64
 76  Rye and products                 135 non-null    float64
 77  Sesame seed                      149 non-null    float64
 78  Sesameseed Oil                   166 non-null    float64
 79  Sorghum and products             80 non-null     float64
 80  Soyabean Oil                     185 non-null    float64
 81  Soyabeans                        184 non-null    float64
 82  Spices, Other                    186 non-null    float64
 83  Sugar (Raw Equivalent)           186 non-null    float64
 84  Sugar beet                       30 non-null     float64
 85  Sugar cane                       77 non-null     float64
 86  Sugar non-centrifugal            31 non-null     float64
 87  Sunflower seed                   106 non-null    float64
 88  Sunflowerseed Oil                184 non-null    float64
 89  Sweet potatoes                   170 non-null    float64
 90  Sweeteners, Other                186 non-null    float64
 91  Tea (including mate)             185 non-null    float64
 92  Tomatoes and products            186 non-null    float64
 93  Vegetables, other                186 non-null    float64
 94  Wheat and products               186 non-null    float64
 95  Wine                             184 non-null    float64
 96  Yams                             108 non-null    float64
dtypes: float64(97)
memory usage: 142.4+ KB

None

Index(['Apples and products', 'Aquatic Animals, Others', 'Aquatic Plants',
       'Bananas', 'Barley and products', 'Beans', 'Beer',
       'Beverages, Alcoholic', 'Beverages, Fermented', 'Bovine Meat',
       'Butter, Ghee', 'Cassava and products', 'Cephalopods', 'Cereals, Other',
       'Citrus, Other', 'Cloves', 'Cocoa Beans and products', 'Coconut Oil',
       'Coconuts - Incl Copra', 'Coffee and products', 'Cottonseed',
       'Cottonseed Oil', 'Cream', 'Crustaceans', 'Dates', 'Demersal Fish',
       'Eggs', 'Fats, Animals, Raw', 'Fish, Body Oil', 'Fish, Liver Oil',
       'Freshwater Fish', 'Fruits, other', 'Grapefruit and products',
       'Grapes and products (excl wine)', 'Groundnut Oil', 'Groundnuts',
       'Honey', 'Infant food', 'Lemons, Limes and products', 'Maize Germ Oil',
       'Maize and products', 'Marine Fish, Other', 'Meat, Aquatic Mammals',
       'Meat, Other', 'Milk - Excluding Butter', 'Millet and products',
       'Miscellaneous', 'Molluscs, Other', 'Mutton & Goat Meat',
       'Nuts and products', 'Oats', 'Offals, Edible', 'Oilcrops Oil, Other',
       'Oilcrops, Other', 'Olive Oil', 'Olives (including preserved)',
       'Onions', 'Oranges, Mandarines', 'Palm Oil', 'Palm kernels',
       'Palmkernel Oil', 'Peas', 'Pelagic Fish', 'Pepper', 'Pigmeat',
       'Pimento', 'Pineapples and products', 'Plantains',
       'Potatoes and products', 'Poultry Meat', 'Pulses, Other and products',
       'Rape and Mustard Oil', 'Rape and Mustardseed', 'Rice and products',
       'Ricebran Oil', 'Roots, Other', 'Rye and products', 'Sesame seed',
       'Sesameseed Oil', 'Sorghum and products', 'Soyabean Oil', 'Soyabeans',
       'Spices, Other', 'Sugar (Raw Equivalent)', 'Sugar beet', 'Sugar cane',
       'Sugar non-centrifugal', 'Sunflower seed', 'Sunflowerseed Oil',
       'Sweet potatoes', 'Sweeteners, Other', 'Tea (including mate)',
       'Tomatoes and products', 'Vegetables, other', 'Wheat and products',
       'Wine', 'Yams'],
      dtype='object', name='Food')

# 6. Merging countries and their sizes of economies:  
size_and_dietary_intake = pd.merge(size_of_economy,
                                        dietary_intake_transposed,
                                        left_index=True,
                                        right_index= True)

display(size_and_dietary_intake.head())

# size_and_dietary_intake.info()

# 7. Checking the Type and Extent of Missing Data

## Splitting the data such that income groups and other fields are separate:
income_groups = size_and_dietary_intake[['Income group']]
# display(income_groups)


data = size_and_dietary_intake.iloc[:, 2:]
# display(data)


dietary_intake_nullity = data.isnull()
# display(dietary_intake_nullity)


## Merging it so that one can group missing values by income groups
dietary_nullity_income_grouped = pd.merge(income_groups,
                                          dietary_intake_nullity,
                                          left_index=True,
                                          right_index=True).groupby('Income group')

percentage_of_nullity = (dietary_nullity_income_grouped.sum() / dietary_nullity_income_grouped.count()) * 100
# display(percentage_of_nullity)



# Visualizing Nullity
percentage_of_nullity_dietary_intake_transposed = percentage_of_nullity.T

ax = percentage_of_nullity_dietary_intake_transposed.plot(kind='barh',
                                                          stacked=True)

ax.figure.set_size_inches(7, 10)
ax.set(xlabel='Percent of Missing Values',
       ylabel='Food Items')
ax.legend(loc='lower right', frameon=False)
#ax.invert_yaxis()
for spine in ['top', 'right'] :
    ax.spines[spine].set_visible(False)
# ax.set_title('Percentage of Missing Values For Each Food Item in Each Income Group', fontdict={'fontsize' : 10})
ax.tick_params(axis='y', which= 'major', labelsize=6)

#plt.set_size_inches(9, 7)
#plt.savefig('Percent_of_Nullity_1st_indicator.png')
plt.show()

# 9. Cleaning the dataset
# 9.1. Replacing 'NaN's with 0's
size_and_dietary_intake_imputed = size_and_dietary_intake.fillna(0.1) 	#print(the_sheet.head())


# 9.2. Grouping the foods into 7 groups : "Cereals", "Roots & Tubers", "Meat, Milk and Products, Eggs", "Vegetables", "Fruits and Plantains", "Seeds, Nuts and Oils", "Starch and Sugars"

daily_intake_aggregated = {
    'Country' : size_and_dietary_intake_imputed.index,
    'Income group' : size_and_dietary_intake_imputed['Income group'].values,
    #'Region' : size_and_dietary_intake_imputed['Region'].values,
    'Cereals' : 0,
    'Roots & Tubers' : 0,
    'Meat, Milk and products & Eggs' : 0,
    'Seeds, Nuts, and Oils' : 0,
    'Starchs & Sugars' : 0
}

daily_intake_aggregated['Cereals'] = \
    	size_and_dietary_intake_imputed['Barley and products']+ \
    	size_and_dietary_intake_imputed['Cereals, Other']+ \
        size_and_dietary_intake_imputed['Maize and products']+ \
        size_and_dietary_intake_imputed['Millet and products']+ \
        size_and_dietary_intake_imputed['Oats']+ \
        size_and_dietary_intake_imputed['Rice and products']+ \
        size_and_dietary_intake_imputed['Rye and products']+ \
        size_and_dietary_intake_imputed['Sorghum and products'] + \
        size_and_dietary_intake_imputed['Wheat and products']
        
daily_intake_aggregated['Roots & Tubers'] = \
    	size_and_dietary_intake_imputed['Cassava and products']+ \
        size_and_dietary_intake_imputed['Potatoes and products']+ \
        size_and_dietary_intake_imputed['Roots, Other']+ \
        size_and_dietary_intake_imputed['Sweet potatoes']+ \
    	size_and_dietary_intake_imputed['Yams'] + \
    	size_and_dietary_intake_imputed['Sugar cane'] + \
        size_and_dietary_intake_imputed['Sugar beet']

daily_intake_aggregated["Dairy & Egg Products"] = \
    size_and_dietary_intake_imputed['Butter, Ghee']+ \
    size_and_dietary_intake_imputed['Cream']+ \
    size_and_dietary_intake_imputed['Eggs'] + \
    size_and_dietary_intake_imputed['Milk - Excluding Butter']

daily_intake_aggregated["Finfish / Shellfish Products"] = \
	size_and_dietary_intake_imputed['Cephalopods']+ \
	size_and_dietary_intake_imputed['Crustaceans']+ \
    size_and_dietary_intake_imputed['Demersal Fish'] + \
    size_and_dietary_intake_imputed['Fish, Body Oil'] + \
    size_and_dietary_intake_imputed['Fish, Liver Oil'] + \
    size_and_dietary_intake_imputed['Freshwater Fish'] + \
    size_and_dietary_intake_imputed['Marine Fish, Other'] + \
    size_and_dietary_intake_imputed['Molluscs, Other']+ \
    size_and_dietary_intake_imputed['Pelagic Fish'] + \
    size_and_dietary_intake_imputed['Aquatic Animals, Others']


daily_intake_aggregated["Poultry"] = \
    size_and_dietary_intake_imputed['Poultry Meat']

daily_intake_aggregated["Pork"] = \
    size_and_dietary_intake_imputed['Pigmeat']


daily_intake_aggregated['Beef Products'] = \
    	size_and_dietary_intake_imputed['Bovine Meat']+ \
        size_and_dietary_intake_imputed['Offals, Edible'] + \
        size_and_dietary_intake_imputed['Fats, Animals, Raw'] + \
        size_and_dietary_intake_imputed['Meat, Other'] + \
        size_and_dietary_intake_imputed['Meat, Aquatic Mammals'] + \
    	size_and_dietary_intake_imputed['Mutton & Goat Meat']
        
daily_intake_aggregated["Spices & Herbs"] = \
    size_and_dietary_intake_imputed['Spices, Other'] + \
    size_and_dietary_intake_imputed['Tea (including mate)'] + \
    size_and_dietary_intake_imputed['Cloves']

daily_intake_aggregated["Legumes & Products"] = \
    size_and_dietary_intake_imputed['Pulses, Other and products']+ \
    size_and_dietary_intake_imputed['Beans']+ \
    size_and_dietary_intake_imputed['Soyabeans']+ \
    size_and_dietary_intake_imputed['Peas']

daily_intake_aggregated['Vegetables'] = \
    size_and_dietary_intake_imputed['Pimento'] + \
    size_and_dietary_intake_imputed['Pepper'] + \
	size_and_dietary_intake_imputed['Onions']+ \
    size_and_dietary_intake_imputed['Vegetables, other'] + \
	size_and_dietary_intake_imputed['Tomatoes and products'] + \
    size_and_dietary_intake_imputed['Aquatic Plants']
    
daily_intake_aggregated['Fruits & Plantains'] = \
    	size_and_dietary_intake_imputed['Bananas']+ \
    	size_and_dietary_intake_imputed['Coconuts - Incl Copra']+ \
    	size_and_dietary_intake_imputed['Dates']+ \
    	size_and_dietary_intake_imputed['Fruits, other']+ \
    	size_and_dietary_intake_imputed['Grapefruit and products'] + \
    	size_and_dietary_intake_imputed['Grapes and products (excl wine)'] + \
    	size_and_dietary_intake_imputed['Lemons, Limes and products'] + \
    	size_and_dietary_intake_imputed['Oranges, Mandarines'] + \
    	size_and_dietary_intake_imputed['Pineapples and products'] + \
    	size_and_dietary_intake_imputed['Plantains'] + \
    	size_and_dietary_intake_imputed['Apples and products'] + \
        size_and_dietary_intake_imputed['Citrus, Other']
    
daily_intake_aggregated['Seeds, Nuts, and Oils'] = \
    	size_and_dietary_intake_imputed['Cocoa Beans and products'] + \
        size_and_dietary_intake_imputed['Maize Germ Oil'] + \
        size_and_dietary_intake_imputed['Nuts and products'] + \
    	size_and_dietary_intake_imputed['Coconut Oil'] + \
        size_and_dietary_intake_imputed['Coconuts - Incl Copra'] + \
    	size_and_dietary_intake_imputed['Coffee and products'] + \
    	size_and_dietary_intake_imputed['Cottonseed Oil'] + \
    	size_and_dietary_intake_imputed['Cottonseed'] + \
        size_and_dietary_intake_imputed['Ricebran Oil'] + \
    	size_and_dietary_intake_imputed['Groundnut Oil'] + \
        size_and_dietary_intake_imputed['Oilcrops Oil, Other'] + \
    	size_and_dietary_intake_imputed['Groundnuts'] + \
        size_and_dietary_intake_imputed['Olive Oil'] + \
        size_and_dietary_intake_imputed['Olives (including preserved)'] + \
    	size_and_dietary_intake_imputed['Oilcrops, Other'] + \
    	size_and_dietary_intake_imputed['Palmkernel Oil'] + \
    	size_and_dietary_intake_imputed['Palm Oil'] + \
    	size_and_dietary_intake_imputed['Palm kernels'] + \
    	size_and_dietary_intake_imputed['Rape and Mustard Oil'] + \
    	size_and_dietary_intake_imputed['Rape and Mustardseed'] + \
    	size_and_dietary_intake_imputed['Sesame seed'] + \
    	size_and_dietary_intake_imputed['Sesameseed Oil'] + \
    	size_and_dietary_intake_imputed['Soyabean Oil'] + \
    	size_and_dietary_intake_imputed['Sunflower seed'] + \
    	size_and_dietary_intake_imputed['Sunflowerseed Oil']
    	#the_sheet_transposed['Nuts and products [2551]'] + \
    
daily_intake_aggregated['Starchs & Sugars'] = \
    	size_and_dietary_intake_imputed['Honey'] + \
    	size_and_dietary_intake_imputed['Sugar (Raw Equivalent)'] + \
    	size_and_dietary_intake_imputed['Sugar non-centrifugal'] + \
    	size_and_dietary_intake_imputed['Sweeteners, Other'] + \
    	size_and_dietary_intake_imputed['Beverages, Fermented']

daily_intake_aggregated['Infant food'] = \
        size_and_dietary_intake_imputed['Infant food']


daily_dietary_intake = pd.DataFrame(daily_intake_aggregated).set_index('Country')


# Removing the "Meat, Milk and products & Eggs column"
daily_dietary_intake = daily_dietary_intake.drop("Meat, Milk and products & Eggs", axis=1)


display(daily_dietary_intake.info())
# daily_dietary_intake.to_csv('Daily Dietary Energy Intake.csv', index=True)

# daily_dietary_intake.head()

<class 'pandas.core.frame.DataFrame'>
Index: 156 entries, Afghanistan to Zimbabwe
Data columns (total 15 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   Income group                  156 non-null    object 
 1   Cereals                       156 non-null    float64
 2   Roots & Tubers                156 non-null    float64
 3   Seeds, Nuts, and Oils         156 non-null    float64
 4   Starchs & Sugars              156 non-null    float64
 5   Dairy & Egg Products          156 non-null    float64
 6   Finfish / Shellfish Products  156 non-null    float64
 7   Poultry                       156 non-null    float64
 8   Pork                          156 non-null    float64
 9   Beef Products                 156 non-null    float64
 10  Spices & Herbs                156 non-null    float64
 11  Legumes & Products            156 non-null    float64
 12  Vegetables                    156 non-null    float64
 13  Fruits & Plantains            156 non-null    float64
 14  Infant food                   156 non-null    float64
dtypes: float64(14), object(1)
memory usage: 19.5+ KB

None

# Checking how good is the sample size

daily_dietary_intake[["Income group","Cereals"]].groupby("Income group").count()

# Checking the distributions and Extreme Values: 1. The Box Plots

fig, ((ax1, ax2), 
      (ax3, ax4), 
      (ax5, ax6), 
      (ax7, ax8), 
      (ax9, ax10), 
      (ax11, ax12), 
      (ax13, ax14)) = plt.subplots(7, 2, sharey=True, sharex=False, figsize=(7, 13))

def distributions(df, x, y, ax) :
    
    """Plots Boxplots for income groups"""
    
    g = sns.boxplot(data=df,
                    ax= ax,
                    x=x,
                    palette='tab10',
                    y=y).set(xlabel='',
                             ylabel='',
                             title=x)
    
    ax.set_title(x, fontsize=8)
    
    ax.tick_params(axis='both', which='major', labelsize=7)
    
    return g

distributions(df=daily_dietary_intake, x="Cereals", y="Income group", ax=ax1)
distributions(df=daily_dietary_intake, x="Roots & Tubers", y="Income group", ax=ax2)
distributions(df=daily_dietary_intake, x="Seeds, Nuts, and Oils", y="Income group", ax=ax3)
distributions(df=daily_dietary_intake, x="Starchs & Sugars", y="Income group", ax=ax4)
distributions(df=daily_dietary_intake, x="Dairy & Egg Products", y="Income group", ax=ax5)
distributions(df=daily_dietary_intake, x="Finfish / Shellfish Products", y="Income group", ax=ax6)
distributions(df=daily_dietary_intake, x="Poultry", y="Income group", ax=ax7)
distributions(df=daily_dietary_intake, x="Pork", y="Income group", ax=ax8)
distributions(df=daily_dietary_intake, x="Beef Products", y="Income group", ax=ax9)
distributions(df=daily_dietary_intake, x="Spices & Herbs", y="Income group", ax=ax10)
distributions(df=daily_dietary_intake, x="Legumes & Products", y="Income group", ax=ax11)
distributions(df=daily_dietary_intake, x="Vegetables", y="Income group", ax=ax12)
distributions(df=daily_dietary_intake, x="Fruits & Plantains", y="Income group", ax=ax13)
distributions(df=daily_dietary_intake, x="Infant food", y="Income group", ax=ax14)

plt.suptitle('Distribution of Values among Different Food Groups', y= 0.95, fontsize=10)
plt.subplots_adjust(hspace= 0.7)
#plt.savefig('Distribution_of_Daily_Kcal_Intakes.png')


# Refer to this code for finer customizations of Seaborn plots.

# Removing Extreme Values

## 9.3. Separating country groups into different datasets.
def income_group_separator(df, col, cat) :

    """Separates a respective income group's data"""
    
    new_df = df[df[col] == cat]
    
    return new_df

low_inc_values = income_group_separator(daily_dietary_intake, 'Income group', 'Low income')

lower_middle_values = income_group_separator(daily_dietary_intake,'Income group', 'Lower middle income')

upper_middle_values = income_group_separator(daily_dietary_intake,'Income group', 'Upper middle income')

high_inc_values = income_group_separator(daily_dietary_intake, 'Income group', 'High income')

# Transforming the data

low_inc_values_transformed = np.log(low_inc_values.iloc[:, 1:])

lower_middle_values_transformed = np.log(lower_middle_values.iloc[:, 1:])

upper_middle_values_transformed = np.log(upper_middle_values.iloc[:, 1:])

high_inc_values_transformed = np.log(high_inc_values.iloc[:, 1:])


transformed_all_groups = pd.concat([low_inc_values_transformed,
                                    lower_middle_values_transformed,
                                    upper_middle_values_transformed,
                                    high_inc_values_transformed])

transformed_data_economized = pd.merge(size_of_economy,
                                       transformed_all_groups,
                                       left_index=True,
                                       right_index=True).drop("Region", axis=1)

transformed_data_economized.head()

/home/mukajanga/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/pandas/core/internals/blocks.py:329: RuntimeWarning: divide by zero encountered in log
  result = func(self.values, **kwargs)

# Visualizing distributions of the transformed data

fig, ((ax1, ax2), 
      (ax3, ax4), 
      (ax5, ax6), 
      (ax7, ax8), 
      (ax9, ax10), 
      (ax11, ax12), 
      (ax13, ax14)) = plt.subplots(7, 2, sharey=False, sharex=False, figsize=(8, 15))

sns.kdeplot(data=transformed_data_economized, x="Cereals", hue="Income group", ax=ax1, legend=False).set(xlabel="", title="Cereals")
sns.kdeplot(data=transformed_data_economized, x="Roots & Tubers", hue="Income group", ax=ax2).set(xlabel="", title="Roots & Tubers")
sns.kdeplot(data=transformed_data_economized, x="Seeds, Nuts, and Oils", hue="Income group", ax=ax3, legend=False).set(xlabel="", title="Seed, Nuts, and Oils")
sns.kdeplot(data=transformed_data_economized, x="Starchs & Sugars", hue="Income group", ax=ax4, legend=False).set(xlabel="", title="Starchs & Sugars")
sns.kdeplot(data=transformed_data_economized, x="Dairy & Egg Products", hue="Income group", ax=ax5, legend=False).set(xlabel="", title="Dairy & Egg Products")
sns.kdeplot(data=transformed_data_economized, x="Finfish / Shellfish Products", hue="Income group", ax=ax6, legend=False).set(xlabel="", title="Finfish / Shellfish Products")
sns.kdeplot(data=transformed_data_economized, x="Poultry", hue="Income group", ax=ax7, legend=False).set(xlabel="", title="Poultry")
sns.kdeplot(data=transformed_data_economized, x="Pork", hue="Income group", ax=ax8, legend=False).set(xlabel="", title="Pork")
sns.kdeplot(data=transformed_data_economized, x="Beef Products", hue="Income group", ax=ax9, legend=False).set(xlabel="", title="Beef Products")
sns.kdeplot(data=transformed_data_economized, x="Spices & Herbs", hue="Income group", ax=ax10, legend=False).set(xlabel="", title="Spices & Herbs")
sns.kdeplot(data=transformed_data_economized, x="Legumes & Products", hue="Income group", ax=ax11, legend=False).set(xlabel="", title="Legumes & Products")
sns.kdeplot(data=transformed_data_economized, x="Vegetables", hue="Income group", ax=ax12, legend=False).set(xlabel="", title="Vegetables")
sns.kdeplot(data=transformed_data_economized, x="Fruits & Plantains", hue="Income group", ax=ax13, legend=False).set(xlabel="", title="Fruits & Plantains")
sns.kdeplot(data=transformed_data_economized, x="Infant food", hue="Income group", ax=ax14, legend=False).set(xlabel="", title="Infant Food")

plt.subplots_adjust(hspace=0.7, wspace= 0.7)

sns.move_legend(ax2, "upper left", bbox_to_anchor=(1, 1), frameon=True)

# Non-normality prevails in three variables: Pork, Spices & Herbs, Infant food. Removing the three variables

transformed_data_cleaned = transformed_data_economized.drop(["Pork", "Spices & Herbs", "Infant food"], axis=1)

transformed_data_cleaned.head(2)

# Renaming the columns so that one can work with the data easily

transformed_data_cleaned.columns = ["income_group",
                                    "cereals",
                                    "roots_and_tubers",
                                    "seeds_nuts_and_oils",
                                    "starches_and_sugars",
                                    "dairy_and_egg_products",
                                    "finfish_and_shellfish_products",
                                    "poultry",
                                    "beef_products",
                                    "legumes_and_products",
                                    "vegetables",
                                    "fruits_and_plantains"]

transformed_data_cleaned.head()

# Running MANOVA

fit = MANOVA.from_formula("cereals + roots_and_tubers + seeds_nuts_and_oils + starches_and_sugars + dairy_and_egg_products + finfish_and_shellfish_products + poultry + beef_products + legumes_and_products + vegetables + fruits_and_plantains ~ income_group", data=transformed_data_cleaned)

print(fit.mv_test())

                    Multivariate linear model
==================================================================
                                                                  
------------------------------------------------------------------
       Intercept         Value    Num DF  Den DF   F Value  Pr > F
------------------------------------------------------------------
          Wilks' lambda   0.0016 11.0000 142.0000 8033.2113 0.0000
         Pillai's trace   0.9984 11.0000 142.0000 8033.2113 0.0000
 Hotelling-Lawley trace 622.2910 11.0000 142.0000 8033.2113 0.0000
    Roy's greatest root 622.2910 11.0000 142.0000 8033.2113 0.0000
------------------------------------------------------------------
                                                                  
------------------------------------------------------------------
          income_group      Value   Num DF  Den DF  F Value Pr > F
------------------------------------------------------------------
              Wilks' lambda 0.1530 33.0000 419.0621 11.3196 0.0000
             Pillai's trace 1.1585 33.0000 432.0000  8.2355 0.0000
     Hotelling-Lawley trace 3.6924 33.0000 322.9836 15.7625 0.0000
        Roy's greatest root 3.1928 11.0000 144.0000 41.7963 0.0000
==================================================================

# After transforming the data; to assess group performance, median was used as a measure of central tendency. This was done in order to retain the robustness that could be obtained by using a full dataset. One can rightly attempt to filter-out the dataset and remove extreme values, but since the result of this would probably still favor the usage of median, it was deemed unnecessary to do that particular data cleaning exercise.

# Although means and medians came considerably close, the presence of extreme values in some food groups compells us to take median as the measure of central tendency.

median_kilo_cal_transposed = daily_dietary_intake.groupby("Income group").median().T

median_kilo_cal_transposed

## 10.2. Visualizing median kilo calories from each income group.

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, sharex=False, sharey=True)
fig.set_size_inches(7, 6)


def bar_plotter(df, x, y, ax, xlabel=None, ylabel=None, palette=None, title=None) :
    
    """Creates bar plots for Income groups"""
    
    g = sns.barplot(x=x,
                    y=y,
                    data= df,
                    ax= ax,
                    palette=palette).set(xlabel='')


    ax.tick_params(axis= 'y', which='major', labelsize=7)
    ax.set_ylabel(ylabel, fontdict={"fontsize" : 8})
    ax.set_xlabel(xlabel, fontdict={'fontsize' : 8})
    ax.set_title(label=x, fontsize=10)
    plt.subplots_adjust(hspace=0.5)



df = median_kilo_cal_transposed

y = median_kilo_cal_transposed.index

yl = 'Food Groups'


bar_plotter(df, x='Low income', y=y, ax=ax1, ylabel=yl, palette="Blues_r")

bar_plotter(df, x='Lower middle income', ax=ax2, y=y, palette="Blues_r")

bar_plotter(df, x='Upper middle income', ax=ax3, y=y, ylabel=yl, palette="Blues_r")

bar_plotter(df, x='High income', y=y, ax=ax4, palette="Blues_r")


plt.suptitle('Median Kilo Calorie Intake From Each Food group', fontsize=10)
plt.savefig('Median Daily_Intake_Kcal.png')
plt.show()

median_kcal_high_income = median_kilo_cal_transposed[['High income']].sort_values('High income', ascending=False)

median_kcal_low_income = median_kilo_cal_transposed[['Low income']].sort_values('Low income' , ascending=False)

median_kcal_lower_middle_income = median_kilo_cal_transposed[['Lower middle income']].sort_values('Lower middle income', ascending=False)

median_kcal_upper_middle_income = median_kilo_cal_transposed[['Upper middle income']].sort_values('Upper middle income', ascending=False)


def percentage_cal(df) :
    
    """Calculates Percentage For Each Food Group"""

    df.loc['Total'] = df.iloc[:, 0].sum()

    numerator = df.iloc[:, 0].values

    denominator = df.loc['Total'].values

    df['Percent'] = np.round(((numerator / denominator) * 100), 1)
    
    return df




food_group_kcal_percent_high_income = percentage_cal(median_kcal_high_income)

food_group_kcal_percent_low_income = percentage_cal(median_kcal_low_income)

food_group_kcal_percent_lower_middle = percentage_cal(median_kcal_lower_middle_income)

food_group_kcal_percent_upper_middle = percentage_cal(median_kcal_upper_middle_income)


display(food_group_kcal_percent_high_income.T)
display(food_group_kcal_percent_low_income.T)
display(food_group_kcal_percent_lower_middle.T)
display(food_group_kcal_percent_upper_middle.T)

# 11. Extracting median daily calory intake from staple & non-staple food from each income group

daily_calories_non_staples_low_income = food_group_kcal_percent_low_income[food_group_kcal_percent_low_income['Percent'] < 12.5]

staples_low_income = food_group_kcal_percent_low_income[food_group_kcal_percent_low_income['Percent'] >= 12.5]


daily_calories_non_staples_high_income = food_group_kcal_percent_high_income[food_group_kcal_percent_high_income['Percent'] < 12.5]

staples_high_income = food_group_kcal_percent_high_income[food_group_kcal_percent_high_income['Percent'] >= 12.5]


daily_calories_non_staples_lower_middle = food_group_kcal_percent_lower_middle[food_group_kcal_percent_lower_middle['Percent'] < 12.5]

staples_lower_middle = food_group_kcal_percent_lower_middle[food_group_kcal_percent_lower_middle['Percent'] >= 12.5]


daily_calories_non_staples_upper_middle = food_group_kcal_percent_upper_middle[food_group_kcal_percent_upper_middle['Percent'] < 12.5]

staples_upper_middle = food_group_kcal_percent_upper_middle[food_group_kcal_percent_upper_middle['Percent'] >= 12.5]



display(daily_calories_non_staples_low_income.T)
display(staples_low_income.T)

display(daily_calories_non_staples_lower_middle.T)
display(staples_lower_middle.T)

display(daily_calories_non_staples_upper_middle.T)
display(staples_upper_middle.T)

display(daily_calories_non_staples_high_income.T)
display(staples_high_income.T)

# Storing results in a single table:

intake_percent_table_index = [
    ['Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Low Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Lower Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'Upper Middle Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income',
     'High Income'],
    ['Cereals',
     'Cereals', 'Cereals', 'Cereals', 'Roots & Tubers', 'Roots & Tubers', 'Roots & Tubers', 'Roots & Tubers', "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", 'Cereals', 'Cereals', 'Cereals', 'Cereals', 'Cereals', 'Cereals', "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", 'Cereals', 'Cereals', 'Cereals', 'Cereals', 'Cereals', "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", "Seeds, Nuts, and Oils", 'Starchs & Sugars', 'Starchs & Sugars', 'Starchs & Sugars', 'Cereals', 'Cereals', 'Cereals', 'Cereals', 'Cereals', 'Seeds, Nuts, and Oils', 'Seeds, Nuts, and Oils','Seeds, Nuts, and Oils', "Dairy & Egg Products", "Dairy & Egg Products", "Dairy & Egg Products"],
    ['55.8', '55.8', '55.8', '55.8', '13.5', '13.5', '13.5', '13.5', '12.6', '12.6', '12.6', '54.6', '54.6', '54.6', '54.6', '54.6', '54.6', '12.8', '12.8', '12.8', '12.8', '12.8', '12.8', '41.8', '41.8', '41.8', '41.8', '41.8', "14.3", "14.3", "14.3", "12.5", "12.5", "12.5", "32.4", "32.4", "32.4", "32.4", "32.4", "15.6", "15.6", "15.6", "13.8", "13.8", "13.8"],
    ['Starchs & Sugars', 'Legumes & Products', 'Fruits & Plantains', 'Dairy & Egg Products', 'Beef Products', 'Vegetables', 'Finfish / Shellfish Products', "Poultry", "Pork", "Spices & Herbs", "Infant Foods", 'Starchs & Sugars', 'Roots & Tubers', 'Dairy & Egg Products', 'Fruits & Plantains', 'Beef Products', "Legumes & Products", 'Vegetables', 'Poultry', 'Finfish / Shellfish Products', 'Pork', 'Spices & Herbs', 'Infant Food', 'Dairy & Egg Products', 'Fruits & Plantains', 'Beef Products', 'Roots & Tubers', 'Poultry', "Vegetables", "Pork", "Legumes & Products", "Finfish / Shellfish Products", "Spices & Herbs", "Infant food", "Starchs & Sugars", "Beef Products", "Pork", "Fruits & Plantains", "Poultry", "Roots & Tubers", "Vegetables", "Finfish / Shellfish Products", "Legumes & Products", "Spices & Herbs", "Infant Food"],
]


intake_percent_table_column = ["4.4", "3.7", '3.5', '2.1', '1.8', '1.4', '0.4', '0.4', '0.4', '0.0', '0.0', '9.0', '5.0', '4.3', '3.9', '3.0', '3.0', '1.8', '1.0', '0.9', '0.6', '0.1', '0.0', '8.6', '4.4', '4.1', '3.4', '3.3', "2.5", "2.2", "1.9", "0.7", "0.1", "0.1", "11.7", "5.7", "5.0", "4.2", "3.6", "2.8", "2.5", "1.5", "1.0", "0.2", "0.1"]

# # display(len(intake_percent_table_column))


intake_percent_table = pd.DataFrame(intake_percent_table_column,
                                    index=intake_percent_table_index,
                                    columns=['Percent of Median Calorie Intake'])

intake_percent_table.index = intake_percent_table.index.rename(['Income group', 'Staple Foods', 'Percent of Median Daily Calorie Intake', 'Non-Staple Foods'])

display(intake_percent_table.style)

# intake_percent_table.to_csv('Daily_Median_Percent_Intakes.csv', index=True)

# Exploratory Data Analysis: Which countries consume more calories from non-staple foods?

# Converting the last column into numerical values

intake_percent_table["Percent of Median Calorie Intake"] = intake_percent_table["Percent of Median Calorie Intake"].astype("float")

assert intake_percent_table["Percent of Median Calorie Intake"].dtype == "float"

intake_percent_table.info()

<class 'pandas.core.frame.DataFrame'>
MultiIndex: 45 entries, ('Low Income', 'Cereals', '55.8', 'Starchs & Sugars') to ('High Income', 'Dairy & Egg Products', '13.8', 'Infant Food')
Data columns (total 1 columns):
 #   Column                            Non-Null Count  Dtype  
---  ------                            --------------  -----  
 0   Percent of Median Calorie Intake  45 non-null     float64
dtypes: float64(1)
memory usage: 2.2+ KB

# Adding the median values from each group

calories_from_non_staples = pd.DataFrame([daily_calories_non_staples_low_income.T.iloc[1].sum(),
                                          daily_calories_non_staples_lower_middle.T.iloc[1].sum(),
                                          daily_calories_non_staples_upper_middle.T.iloc[1].sum(),
                                          daily_calories_non_staples_high_income.T.iloc[1].sum()],
                                          index=["Low income", 
                                                 "Lower middle income",
                                                 "Upper middle income",
                                                 "High income"],
                                          columns= ["Percent of kcal from non-staple foods"]).sort_values("Percent of kcal from non-staple foods", ascending=False)

calories_from_non_staples

# Plotting the above information

fig, ax = plt.subplots()
fig.set_size_inches(6, 4)

df = calories_from_non_staples

bar_plotter(x="Percent of kcal from non-staple foods",
            y=df.index,
            df=df,
            ax=ax,
            xlabel="Percent of Kcal from non-staple foods",
            #ylabel="Income groups",
            palette="Blues_r")

plt.show()

# Number of countries from each group in this indicator:

daily_dietary_intake.groupby("Income group").count()

# 1. Reading-in the dataset from FAO

food_supply = pd.read_csv('Food Quantity Data.csv',
                          sep= ',',
                          names= ['Country', 'Item', 'Value'])

#display(food_supply.head(30))

copy_food_supply = food_supply.copy(deep= True).drop(0)

display(copy_food_supply.head(10))

# 2. Transposing the Data so that each country is represented as a one row:
transposed_copy_of_food_supply = copy_food_supply.pivot(
    index= 'Country',
    columns= 'Item',
    values= 'Value'
)

display(transposed_copy_of_food_supply.head())
#display(transposed_copy_of_food_supply.info())

# 3. Changing the data type. Data in all columns was as objects, not numbers.
transposed_copy_copy = transposed_copy_of_food_supply.copy(deep= True)#.fillna(0)

transposed_copy_cleaned = transposed_copy_copy.loc[:,:].astype('float')

#assert transposed_copy_cleaned.loc[:,:].dtype == 'float'

display(transposed_copy_cleaned.head())

# 4. Attaching countries' regions and sizes of economy
transposed_copy_with_size_and_region = pd.merge(size_of_economy,
                                                transposed_copy_cleaned,
                                                left_index=True,
                                                right_index=True
                                               )

display(transposed_copy_with_size_and_region.head())

# 5. Dealing with Missing Data: Determining the type.

## 5.1. Checking to see if there is any relationship between income group and missing data on a specific food item:

transposed_copy_nullity = transposed_copy_cleaned.isnull()

# display(transposed_copy_nullity)

transposed_copy_nullity_with_regions = pd.merge(size_of_economy,
                                                transposed_copy_nullity,
                                                left_index=True,
                                                right_index=True
                                               )
#display(transposed_copy_nullity_with_regions.head())

country_count_each_inc_group = pd.DataFrame(transposed_copy_with_size_and_region['Income group'].value_counts())

country_count_each_inc_group.columns = ['Total Count']

display(country_count_each_inc_group)

## 5.2. Percentage of missing values for each food group in each income group
nullity_by_income_group = transposed_copy_nullity_with_regions.groupby('Income group').sum().iloc[:, 1:]

count_of_countries = transposed_copy_nullity_with_regions.groupby('Income group').count().iloc[:, 1:]

percentage_of_nullity_of_food_groups = nullity_by_income_group.div(count_of_countries) * 100

display(percentage_of_nullity_of_food_groups)

percentage_of_nullity_of_food_groups_pivoted = percentage_of_nullity_of_food_groups.T

#display(percentage_of_nullity_of_food_groups_pivoted)



## 5.3. Visualizing Missingness

#fig = plt.figure()
#fig.set_size_inches(10, 7)

ax = percentage_of_nullity_of_food_groups_pivoted.plot(kind= 'barh',
                                  stacked=True)

ax.figure.set_size_inches(7, 10)
ax.set(xlabel='Percent of Missing Values',
       ylabel='Food Items')
ax.legend(loc='upper right', frameon=False)
for spine in ['top', 'right'] :
    ax.spines[spine].set_visible(False)
ax.set_title('Percentage of Missing Values For Each Food Item in Each Income Group', fontdict={'fontsize' :10})
ax.tick_params(axis='y', which= 'major', labelsize=6)
ax.invert_yaxis()


# plt.savefig("missing_values_shannon.png")

## 5.4. Encoding the categorical values of Region and Size of Economy:  

### 5.4.1. Making sure there aren't any missing values

regions_nullity = transposed_copy_with_size_and_region['Region'].isnull()

size_of_economy_nullity = transposed_copy_with_size_and_region['Income group'].isnull()

print("Region nullity: {}".format(regions_nullity.sum()))

print("Nullity in Size of Economy: {}".format(size_of_economy_nullity.sum()))

Region nullity: 0
Nullity in Size of Economy: 0

## There was one un-classified country in-terms of size-of-economy: Venezuela. Up to the time you're reading this, it is no longer in the dataset. So run the block as it is.

size_of_economy_missing_val = size_of_economy_nullity[size_of_economy_nullity == True]

display(size_of_economy_missing_val)


# Removing Venezuela
#adjusted_transposed_copy = transposed_copy_with_size_and_region.drop('Venezuela, RB', axis=0)

adjusted_transposed_copy = transposed_copy_with_size_and_region

size_of_economy_nullity_updated = adjusted_transposed_copy['Income group'].isnull().sum()

#print("Updated Number of Nullity at Size of Economy / Income group: {}".format(size_of_economy_nullity_updated))

Series([], Name: Income group, dtype: bool)

# Encoding
encoder = OrdinalEncoder()

regions = adjusted_transposed_copy['Region']

income_groups = adjusted_transposed_copy['Income group']

display(pd.DataFrame(regions.unique()))
display(pd.DataFrame(income_groups.unique()))

reshaped_regions = regions.values.reshape(-1, 1)

reshaped_income_groups = income_groups.values.reshape(-1, 1)

#display(reshaped_regions)

encoded_regions = encoder.fit_transform(reshaped_regions)

encoded_income_groups = encoder.fit_transform(reshaped_income_groups)
adjusted_transposed_copy_for_encoding = adjusted_transposed_copy.copy(deep=True)

adjusted_transposed_copy_for_encoding[adjusted_transposed_copy_for_encoding.columns[1]] = np.squeeze(encoded_regions)
#adjusted_transposed_copy_for_encoding.loc[:, 'Region'] = np.squeeze(encoded_regions) ---> A clearer code, but results into a FutureWarning Error

adjusted_transposed_copy_for_encoding[adjusted_transposed_copy_for_encoding.columns[0]] = np.squeeze(encoded_income_groups)
#adjusted_transposed_copy_for_encoding.loc[:, 'Income group'] = np.squeeze(encoded_income_groups)

display(adjusted_transposed_copy_for_encoding.head(10))

## 5.5. Preparing Data For Imputation

excessive_missing_values = percentage_of_nullity_of_food_groups_pivoted[percentage_of_nullity_of_food_groups_pivoted.iloc[:, :] > 40]

display(excessive_missing_values.info())

<class 'pandas.core.frame.DataFrame'>
Index: 92 entries, Apples and products to Yams
Data columns (total 4 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   High income          11 non-null     float64
 1   Low income           6 non-null      float64
 2   Lower middle income  9 non-null      float64
 3   Upper middle income  10 non-null     float64
dtypes: float64(4)
memory usage: 5.6+ KB

None

items_without_excessive_missingness = percentage_of_nullity_of_food_groups_pivoted[percentage_of_nullity_of_food_groups_pivoted.iloc[:, :] < 40].dropna()

#display(items_without_excessive_missingness.info())

items_without_excessive_missingness_transposed = items_without_excessive_missingness.T

food_item_list = list(items_without_excessive_missingness_transposed.columns)

#display(food_item_list)


raw_data_for_imputation = adjusted_transposed_copy_for_encoding[food_item_list]

complete_data_for_imputation = pd.merge(adjusted_transposed_copy_for_encoding.iloc[:, 0:2],
                                        raw_data_for_imputation,
                                        left_index=True,
                                        right_index=True)

#display(complete_data_for_imputation.info())



## 5.6.1. Imputing by KNN

knn_imputer = KNN()

imputed_by_knn = pd.DataFrame(knn_imputer.fit_transform(complete_data_for_imputation),
                              columns=complete_data_for_imputation.columns)


## 5.6.2. Imputing by MICE

mice = IterativeImputer()

imputed_by_mice = np.round(pd.DataFrame(mice.fit_transform(complete_data_for_imputation),
                                        index=complete_data_for_imputation.index,
                                        columns=complete_data_for_imputation.columns), 1)


## 5.6.3. Evaluating accuracy of the two methods

# Checking the R-Statistic

# KNN_imputed:

Xknn = sm.add_constant(imputed_by_knn.iloc[:, :-1])
yknn = imputed_by_knn.iloc[:, -1]
lm_knn = sm.OLS(yknn, Xknn).fit()


# MICE_imputed:
Xmice = sm.add_constant(imputed_by_mice.iloc[:, :-1])
ymice = imputed_by_mice.iloc[:, -1]
lm_mice = sm.OLS(ymice, Xmice).fit()



r_squares = pd.DataFrame(dict(KNN_Imputed = lm_knn.rsquared,
                              MICE_Imputed = lm_mice.rsquared), 
                         index= ['Adj. Rsquared'])

coefficients = pd.DataFrame(dict(KNN_Imputed = lm_knn.params,
                                 MICE_Imputed = lm_mice.params))

coefficients_combined = pd.concat((r_squares, coefficients), axis= 0)

display(coefficients_combined.head(2))

#coefficients_combined.to_csv('MICE_vs_KNN_2nd_indicator.csv')

Imputing row 1/156 with 10 missing, elapsed time: 0.015
Imputing row 101/156 with 4 missing, elapsed time: 0.023

#display(imputed_by_mice.info())

# Creating a list of Food Items. Use this as a reference when aggregating food items into food groups.
food_items = pd.DataFrame(list(imputed_by_mice.columns),
                          columns= ['Food Items'])
#food_items.to_csv('Food_Items_mod.csv', index=False)



# Combining Foods into Food Groups:
aggregated_food_supplies = {
    'Cereals' : 0,
    'Roots & Tubers' : 0,
    'Vegetables' : 0,
    'Fruits & Plantains' : 0,
    'Seeds, Nuts, and Oils' : 0,
    'Starch and Sugars' : 0,
    'Infant Food' : 0
}


#aggregated_food_supplies['Income group'] = imputed_by_mice['Income group'].values.reshape(-1, 1)

aggregated_food_supplies['Cereals'] = \
        imputed_by_mice['Barley and products'] + \
        imputed_by_mice['Wheat and products'] + \
        imputed_by_mice['Cereals, Other'] + \
        imputed_by_mice['Maize and products'] + \
        imputed_by_mice['Oats'] + \
        imputed_by_mice['Rice and products'] + \
        imputed_by_mice['Rye and products']


aggregated_food_supplies['Roots & Tubers'] = \
        imputed_by_mice['Potatoes and products'] + \
        imputed_by_mice['Roots, Other'] + \
        imputed_by_mice['Sweet potatoes']


aggregated_food_supplies["Dairy and Egg Products"] = \
        imputed_by_mice['Butter, Ghee'] + \
        imputed_by_mice['Cream'] + \
        imputed_by_mice['Eggs'] + \
        imputed_by_mice['Milk - Excluding Butter']


aggregated_food_supplies["Finfish / Shellfish Products"] = \
        imputed_by_mice['Cephalopods'] + \
        imputed_by_mice['Crustaceans'] + \
        imputed_by_mice['Demersal Fish'] + \
        imputed_by_mice['Freshwater Fish'] + \
        imputed_by_mice['Marine Fish, Other'] + \
        imputed_by_mice['Molluscs, Other'] + \
        imputed_by_mice['Pelagic Fish']

aggregated_food_supplies['Beef Products'] = \
        imputed_by_mice['Aquatic Animals, Others'] + \
        imputed_by_mice['Bovine Meat'] + \
        imputed_by_mice['Fats, Animals, Raw'] + \
        imputed_by_mice['Meat, Other'] + \
        imputed_by_mice['Mutton & Goat Meat'] + \
        imputed_by_mice['Offals, Edible']

aggregated_food_supplies["Poultry"] = \
        imputed_by_mice['Poultry Meat']
    
aggregated_food_supplies['Starch and Sugars'] = \
        imputed_by_mice['Honey'] + \
        imputed_by_mice['Sweeteners, Other'] + \
        imputed_by_mice['Sugar (Raw Equivalent)']
        

aggregated_food_supplies["Legume and Legume Products"] = \
        imputed_by_mice['Beans'] + \
        imputed_by_mice['Peas'] + \
        imputed_by_mice['Soyabeans'] + \
        imputed_by_mice['Pulses, Other and products']


aggregated_food_supplies["Spices & Herbs"] = \
        imputed_by_mice['Cloves'] + \
        imputed_by_mice['Spices, Other'] + \
        imputed_by_mice['Tea (including mate)']

aggregated_food_supplies['Vegetables'] = \
        imputed_by_mice['Aquatic Plants'] + \
        imputed_by_mice['Onions'] + \
        imputed_by_mice['Pepper'] + \
        imputed_by_mice['Pimento'] + \
        imputed_by_mice['Vegetables, other'] + \
        imputed_by_mice['Tomatoes and products']
        
    
aggregated_food_supplies['Fruits & Plantains'] = \
        imputed_by_mice['Apples and products'] + \
        imputed_by_mice['Bananas'] + \
        imputed_by_mice['Citrus, Other'] + \
        imputed_by_mice['Oranges, Mandarines'] + \
        imputed_by_mice['Dates'] + \
        imputed_by_mice['Fruits, other'] + \
        imputed_by_mice['Grapefruit and products'] + \
        imputed_by_mice['Grapes and products (excl wine)'] + \
        imputed_by_mice['Lemons, Limes and products'] + \
        imputed_by_mice['Olives (including preserved)'] + \
        imputed_by_mice['Pineapples and products'] + \
        imputed_by_mice['Plantains']
    
    
aggregated_food_supplies['Seeds, Nuts, and Oils'] = \
        imputed_by_mice['Cocoa Beans and products'] + \
        imputed_by_mice['Coconut Oil'] + \
        imputed_by_mice['Coconuts - Incl Copra'] + \
        imputed_by_mice['Coffee and products'] + \
        imputed_by_mice['Cottonseed Oil'] + \
        imputed_by_mice['Fish, Body Oil'] + \
        imputed_by_mice['Fish, Liver Oil'] + \
        imputed_by_mice['Groundnut Oil'] + \
        imputed_by_mice['Groundnuts'] + \
        imputed_by_mice['Nuts and products'] + \
        imputed_by_mice['Maize Germ Oil'] + \
        imputed_by_mice['Oilcrops Oil, Other'] + \
        imputed_by_mice['Oilcrops, Other'] + \
        imputed_by_mice['Olive Oil'] + \
        imputed_by_mice['Palm Oil'] + \
        imputed_by_mice['Palmkernel Oil'] + \
        imputed_by_mice['Rape and Mustard Oil'] + \
        imputed_by_mice['Rape and Mustardseed'] + \
        imputed_by_mice['Sesame seed'] + \
        imputed_by_mice['Sesameseed Oil'] + \
        imputed_by_mice['Sunflowerseed Oil'] + \
        imputed_by_mice['Soyabean Oil']
    
    
aggregated_food_supplies['Infant Food'] = \
        imputed_by_mice['Infant food']



df_aggregated_food_supplies = pd.merge(adjusted_transposed_copy[['Income group', 'Region']],
                                       pd.DataFrame(aggregated_food_supplies, index=imputed_by_mice.index),
                                       left_index=True,
                                       right_index=True).sort_values('Income group')

display(df_aggregated_food_supplies.head(5))

df_aggregated_food_supplies.to_csv('1_Aggregated_Food_Supplies.csv', index=True)

# Creating a function for calculating Shannon_diversity

def Shannon_diversity(dataframe) :
    """Calculates Shannon Diversity from the DataFrame"""

    # Creating the "Total Column"
    dataframe.loc[:, "Total"] = dataframe.sum(axis=1)


    # Removing zeroes and NaNs (Dividing columns with these values to the total will bring something nobody wants.)
    some_list = list()
    
    for i, val in dataframe.iterrows():
        j = dataframe.loc[[i]].dropna(axis=1)

        j = j.loc[:, (j != 0).any(axis=0)]

        some_list.append(j)

    
    # The Shannon Diversity Index
    container_1 = list()

    for i in range(len(some_list)):
        frame = some_list[i]

        container_2 = list()

        for col in frame :
            if col != "Total":
                d_index = abs(frame[col] / frame["Total"] * np.log(frame[col] / frame["Total"]))

                container_2.append(d_index)
            else:
                continue

            index_array = np.array(container_2).sum()


        container_1.append(index_array)


    dataframe.loc[:, "Production Diversity Indeces"] = container_1

    return pd.DataFrame(dataframe.loc[:, "Production Diversity Indeces"])

# Calculating Shannon Diversity Indeces for countries in the food supply table

food_supply_diversity_shannon = Shannon_diversity(df_aggregated_food_supplies.iloc[:, 2:])

food_supply_diversity_shannon

# Attaching the Shannon data with sizes of economy

food_supply_diversity_economized = pd.merge(size_of_economy,
                                            food_supply_diversity_shannon,
                                            left_index=True,
                                            right_index=True).drop("Region", axis=1)

food_supply_diversity_economized

# Separating Income groups and scaling them (Later proved unnecesary)

scaled_shannon_low_income = scaler(food_supply_diversity_economized[food_supply_diversity_economized["Income group"] == "Low income"], column= "Production Diversity Indeces")

scaled_shannon_lower_middle = scaler(food_supply_diversity_economized[food_supply_diversity_economized["Income group"] == "Lower middle income"], column="Production Diversity Indeces")

scaled_shannon_upper_middle = scaler(food_supply_diversity_economized[food_supply_diversity_economized["Income group"] == "Upper middle income"], column="Production Diversity Indeces")

scaled_shannon_high_income = scaler(food_supply_diversity_economized[food_supply_diversity_economized["Income group"] == "High income"], column="Production Diversity Indeces")


scaled_total = pd.concat([scaled_shannon_low_income,
                          scaled_shannon_lower_middle,
                          scaled_shannon_upper_middle,
                          scaled_shannon_high_income])

scaled_total.head()

/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values

# Plotting the Box plots to check for extreme values

fig, ax = plt.subplots()

sns.boxplot(data=scaled_total, x="Production Diversity Indeces", y="Income group")

plt.show()

# Plotting the Distribution curve to see normality

fig, ax = plt.subplots()

sns.kdeplot(data=scaled_total, x="Production Diversity Indeces", hue="Income group", palette="Blues")

plt.show()

# Normality and Heteroskedasticity are good. Moving on to EDA and ANOVA

# Renaming the columns so that they can be able to be processed by the ANOVA model

scaled_total.columns = ["income_group", "diversity_indeces", "scaled_diversity_indeces"]

scaled_total.head()

# Dropping the column "scaled_diversity_indeces" because it is useless.

scaled_total = scaled_total.drop("scaled_diversity_indeces", axis=1)

scaled_total.head()

# Exploratory Data Analysis: Whlich country group has higher diversity

food_diversity_grouped_by_mean = scaled_total.groupby("income_group").mean()

display(food_diversity_grouped_by_mean)

food_diversity_grouped_by_median = scaled_total.groupby("income_group").median()

display(food_diversity_grouped_by_median)

# ANOVA

# Creating and fitting the linear model
model = ols("diversity_indeces ~ C(income_group)", data=scaled_total).fit()

# Accessing ANOVA coefficients
anova_table = sm.stats.anova_lm(model, typ=2)

anova_table

# Rescaling the median values, the right way this time

shannon_diversity_median_scaled = food_diversity_grouped_by_median.sort_values("diversity_indeces", ascending=False)

shannon_diversity_median_scaled["scaled_values"] = shannon_diversity_median_scaled["diversity_indeces"] * 100/np.log(13)

shannon_diversity_median_scaled.head()

# Plotting the information above

fig, ax = plt.subplots()
fig.set_size_inches(6, 4)

sns.barplot(x="scaled_values",
            y= shannon_diversity_median_scaled.index,
            data=shannon_diversity_median_scaled,
            palette="Blues_r").set_xlabel("Shannon Diversity Scaled (0=Worst, 100=Best)")

plt.show()

# Number of countries from each group in this indicator

scaled_total.groupby("income_group").count()

#1. Merging the Food Supply Data from FAO and the Food Composition table.

# 1.1 Taking a glimpse of the food supply data to see the names of the foods used there.

display(imputed_by_mice.head(3))

# 1.2 Importing the Food Composition Data

# food_composition_table = pd.read_csv('food_composition_data.csv')

# display(food_composition_table.head())


# food_composition_table.pivot_table(index= ["food_name", "food_group"],
#                                    columns="nutr_name",
#                                    values="nutr_value").iloc[60:80]

# DO NOT RUN THIS PIECE OF CODE. ITS OUTPUT HAS ALREADY BEEN SAVED AND USED IN THE NEXT CODE SNIPPETS.


## 1.5 Condensing food items such that we've a median value of nutrient values of each nutrient from each food type.

### I. Take a peek of your data

#display(food_composition_transposed.head())


### II. The initial columns' names are confusing. Taking them to the back

# food_compos_modified = food_composition_transposed[food_composition_transposed.columns.sort_values(ascending=False)]

#display(food_compos_modified.head())



### III. We don't want an index name for the columns. Removing it, and resetting row indexes to be food codes.

# better_food_compos_table = food_compos_modified.rename_axis(None, axis=1).reset_index()

# better_food_compos_table_1 = better_food_compos_table.set_index('food_code')

#display(better_food_compos_table_1.head())



### IV. Beginning condensing the foods: Writting a program that will do just that

# condensed_foods = pd.DataFrame()

# food_compos_aft_reduction = pd.DataFrame


def food_condenser() :    
    """ Condenses similar food types of a similar food group from the food_composition table """
    
    
    # Designing a better user experience btn the 1st iteration and the subsequent ones
    first_iter = 0
    
    new_iter = 0
    
    
    # Iteration starts
    while new_iter == first_iter :
        
        new_iter = 1 + first_iter
        
        start = input('Welcome. Should I start condensing? [Y/n]: ').upper()
        
        while start == 'Y' :
    
            print("""
            This is a preview of the food composition table as it is now. \n
            Please choose any word from the "food_name" column and the "food_group" column \n
            and then enter them in the prompts that follow..\n
            DO NOT WRITE the whole string for the food name, just the main food type (eg. butter, cheese, etc,)
            For the Food Group name, write the whole name. \n
            
            ATTENTION: Names in the "food_group" column are case sensitive.
            """.upper())
        
            display(better_food_compos_table_1.head(4))
            
            
            # Taking the group name
            food_group = input('Please write the food_group name: ')
            
            
            # Filtering the main_compos table for the aforementioned food_group
            group = better_food_compos_table_1[better_food_compos_table_1['food_group'].str.contains(food_group)]
            
            
            # Cutting of the desired food_group from the main-compos table
            remaining_groups = better_food_compos_table_1[ ~better_food_compos_table_1['food_group'] \
                                                         .isin(group['food_group'])
                                                        ]
            
            
            # Updating the food_compos table such that we only have food that haven't been condensed:
            food_compos_aft_reduction = remaining_groups
            
            
            # Getting the medium values for all nutrients in the desired food_and_food_group table
            median_vals = pd.DataFrame(data=group.iloc[:, 2:].aggregate('median', axis=0)).T
            
            
            # Attaching the food_name and food_group_name to the median values
            food_name = pd.DataFrame(data=[food_group], columns=['food_group'])

            compressed_values = pd.concat([food_name, median_vals], axis=1)
            
            
            # Attaching this to the "Condensed_foods" table
            
            global condensed_foods
            
            condensed_foods = pd.concat([condensed_foods, compressed_values], axis=0)
            
            display(condensed_foods)
            
            start = 'n'

    
    # For Subsequent iterations
    continuation = input('Do you want to repeat this process? [Y/n]: ').upper()
    
    
    while continuation == 'Y' :
            
        count = new_iter + 1
            
        print("""The names in the "food_group" column are case sensitive, remember that.\n
        This is the preview of the table as it is now.""".upper())
            
        display(food_compos_aft_reduction.head(4))
            
            
        # Taking the name of the food
        #name = input('Please write the food name: ').upper()
            
            
        # Taking the group name
        food_group = input('Please write the food_group name: ')
            
            
        # Filtering the main_compos table for the aforementioned food
        group = food_compos_aft_reduction[food_compos_aft_reduction['food_group'].str.contains(food_group)]
            
            
        # Cutting of the desired food from the main-compos table
        remaining_groups = food_compos_aft_reduction[ ~food_compos_aft_reduction['food_name'] \
                                                         .isin(group['food_name'])
                                                        ]
            
            
        # Updating the food_compos table such that we only have food that haven't been condensed:
        food_compos_aft_reduction = remaining_groups
            
            
        # Getting the medium values for all nutrients in the desired food_and_food_group table
        median_vals = pd.DataFrame(data=group.iloc[:, 2:].aggregate('median', axis=0)).T
            
            
        # Attaching the food_name and food_group_name to the median values
        food_name = pd.DataFrame(data=[food_group], columns=['food_group'])

        compressed_values = pd.concat([food_name, median_vals], axis=1)
            
            
        # Attaching this to the "Condensed_foods" table
        condensed_foods = pd.concat([condensed_foods, compressed_values], axis=0)
        
        
        # displaying the new "condensed_foods" table
        display(condensed_foods)
                
        # Re-running the procedure
        continuation = input('Do you want to repeat this process? [Y/n]: ').upper()
        
        
    return condensed_foods


# Condensing: Iteration 1:
#food_condenser()

#display(condensed_foods)

# Saving the output table to a variable and resetting the index
#condensed_food_compos = condensed_foods.reset_index()

#display(condensed_food_compos)


# Removing the first "index" column:
#condensed_food_compos_table = condensed_food_compos.drop("index", axis=1)

#display(condensed_food_compos_table)


# Saving the output to csv:
#condensed_food_compos_table.to_csv("Condensed_Food_Composition_Table.csv", index=True)

# UPLOADING THE TABLE ABOVE AGAIN AFTER SOME TIME

nutritional_content_table = pd.read_csv("01. Clean Datasets/Metric_1/Indicator_3/1_Condensed_Food_Composition_Table.csv")

display(nutritional_content_table.head())

# Removing the column "Unnamed" and the last row that is empty:
nutrition_table = nutritional_content_table.iloc[:17, 1:].set_index("food_group")

#display(nutrition_table)

groups_nutrition_table = nutrition_table.index

#display(groups_nutrition_table)



# Combining the groups such that one has groups equal to the ones in the intake tables.
nutrition_table

nutrition_table.loc["Beef Products"] = nutrition_table.loc["Beef Products"] + \
                                       nutrition_table.loc["Sausages and Luncheon Meats"]

nutrition_table.loc["Seeds, Nuts, and Oils"] = nutrition_table.loc["Nut and Seed Products"] + \
                                    nutrition_table.loc["Fats and Oils"]

nutrition_table.loc["Breakfast Cereals"] = nutrition_table.loc["Breakfast Cereals"] + \
                                           nutrition_table.loc["Soups, Sauces, and Gravies"] + \
                                           nutrition_table.loc["Snacks"]

nutrition_table = nutrition_table.drop(["Sausages and Luncheon Meats", 
                                        "Fats and Oils", 
                                        "Soups, Sauces, and Gravies", 
                                        "Snacks",
                                        "Nut and Seed Products"])

nutrition_table

# Checking the modified functional diversity of the groups above before we combine them to make the seven groups we've been using since the beginning.

# Writing the MFAD function
def MFAD(df):
    """Calculates the MFAD value for a given df"""

    # Giving the user the picture of their dataset
    display("""Below is the dataframe as it is now:""")

    display(df)

    proceed = input("Do you want to proceed [y/n]: ").upper()


    # Calculating the MFAD
    MFAD_values = list()


    # defining the starting and ending points of the summation symbols.
    n = range(1, df.index.__len__()+1)
    
    while proceed == "Y" :
        species = int(input("Put the index of the item you want to use as your 'i': "))

        for j, val in df.iterrows():
            if j == df.iloc[[species]].index :
                continue
            else :
                distance = np.sqrt(((df.iloc[species] - val)**2).sum()) # Calculates the Eucledian distance.

                mfad = (distance / df.columns.__len__()) / 10000 # Completes the MFAD formula

                i = df.iloc[[species]].index.item() # Extracts the index for the i

                MFAD_values.append({f"{i} - {j}" : mfad})

        proceed = input("Do you have more food items for eucledian distance? [y/n]:").upper()

    
    MFAD_values = pd.DataFrame(MFAD_values).T#.rename_axis("eucledian(i - j)").T


    # Creating a program that names columns according to the number of items in the dataset.
    frame = pd.DataFrame()

    some_list = list()
    
    # Removing NAN's from each row in the dataset
    for i, val in MFAD_values.iterrows():
        j = MFAD_values.loc[[i]].dropna(axis=1)

        some_list.append(j)

        
    for i in range(0, len(some_list)) :
        some_list[i].columns = ["mfad_values"]

        frame = pd.concat([frame, some_list[i]], axis=0, ignore_index=False)

    # Removing duplicate values
    clean_frame = frame.drop_duplicates()


    # # Normalizing the MFAD values
    # clean_frame.loc[:, "Normalized_MFAD"] = (clean_frame["mfad_values"] - clean_frame["mfad_values"].mean()) /\
    #                                           (clean_frame["mfad_values"].max() - clean_frame["mfad_values"].min())


    # # Summing the mfad values from each iteration of i/j up to n
    clean_frame.loc["Total"] = clean_frame["mfad_values"].sum()

    return clean_frame

# Loading the food supply table

df_aggregated_food_supplies.head()

# Grouping the data according to "Income group"

food_supplies_grouped = df_aggregated_food_supplies.drop("Region", axis=1).groupby("Income group")

median_food_supplies = food_supplies_grouped.median()

mean_food_supplies = food_supplies_grouped.mean()

# display(median_food_supplies)
# display(mean_food_supplies)

# The median_food_supplies table was taken for data robustness

## Multiplying the values to turn them into grams. Multiplied by ten because the values in the composition table are expressed in-terms of 100 grams.

median_food_supplies_in_grams = np.round(mean_food_supplies * 10)

median_food_supplies_in_grams

# Checking the food group names in the composition table

nutrition_table

# Multiplying values from each income group to determine the nutrient supply in the economy

# Creating a function that'll do that
def nutrient_supply(df) :
    """Calculates nutrient supplies for a particular country or country group"""

    column_names = list(nutrition_table.columns.values)

    index_names = list(df.columns.values)

    index_names.remove("Roots & Tubers")

    nutrient_supplies = pd.DataFrame([df["Cereals"].values * nutrition_table.loc["Breakfast Cereals"].values,
                                      df["Vegetables"].values * nutrition_table.loc["Vegetables and Vegetable Products"].values,
                                      df["Fruits & Plantains"].values * nutrition_table.loc["Fruits and Fruit Juices"].values,
                                      df["Seeds, Nuts, and Oils"].values * nutrition_table.loc["Seeds, Nuts, and Oils"].values,
                                      df["Starch and Sugars"].values * nutrition_table.loc["Beverages"].values,
                                      df["Infant Food"].values * nutrition_table.loc["Baby Foods"].values,
                                      df["Dairy and Egg Products"].values * nutrition_table.loc["Dairy and Egg Products"].values,
                                      df["Finfish / Shellfish Products"].values * nutrition_table.loc["Finfish and Shellfish Products"].values,
                                      df["Beef Products"].values * nutrition_table.loc["Beef Products"].values,
                                      df["Poultry"].values * nutrition_table.loc["Poultry Products"].values,
                                      df["Legume and Legume Products"].values * nutrition_table.loc["Legumes and Legume Products"].values,
                                      df["Spices & Herbs"].values * nutrition_table.loc["Spices and Herbs"].values])
    
    nutrient_supplies.columns = column_names

    nutrient_supplies.index = index_names
    
    return nutrient_supplies



nutrient_supply_high_income = nutrient_supply(median_food_supplies_in_grams.loc[["High income"]])

nutrient_supply_upper_middle = nutrient_supply(median_food_supplies_in_grams.loc[["Upper middle income"]])

nutrient_supply_lower_middle = nutrient_supply(median_food_supplies_in_grams.loc[["Lower middle income"]])

nutrient_supply_low_income = nutrient_supply(median_food_supplies_in_grams.loc[["Low income"]])


# Just for checking if everything worked out

display(nutrient_supply_lower_middle)

# Calculating the MFAD values for each nutrient supply table

# mfad_low_income = MFAD(nutrient_supply_low_income)

# mfad_high_income = MFAD(nutrient_supply_high_income)

# mfad_lower_middle = MFAD(nutrient_supply_lower_middle)

# mfad_upper_middle = MFAD(nutrient_supply_upper_middle)


# Just Checking one of the output

# mfad_lower_middle

# Saving the outputs of the tables above so that I don't have to re-run the piece of code above

# mfad_low_income.to_csv("01. Clean Datasets/Metric_1/Indicator_3/3_mfad_low_income.csv")

# mfad_lower_middle.to_csv("01. Clean Datasets/Metric_1/Indicator_3/4_mfad_lower_middle.csv")

# mfad_upper_middle.to_csv("01. Clean Datasets/Metric_1/Indicator_3/5_mfad_upper_middle.csv")

# mfad_high_income.to_csv("01. Clean Datasets/Metric_1/Indicator_3/6_mfad_high_income.csv")

# Loading in the mfad datasets: You have to the set index again as Microsoft re-indexes the frame automatically when you save it in csv 
mfad_low_income = pd.read_csv("01. Clean Datasets/Metric_1/Indicator_3/3_mfad_low_income.csv").set_index("Unnamed: 0")

mfad_lower_middle = pd.read_csv("01. Clean Datasets/Metric_1/Indicator_3/4_mfad_lower_middle.csv").set_index("Unnamed: 0")

mfad_upper_middle = pd.read_csv("01. Clean Datasets/Metric_1/Indicator_3/5_mfad_upper_middle.csv").set_index("Unnamed: 0")

mfad_high_income = pd.read_csv("01. Clean Datasets/Metric_1/Indicator_3/6_mfad_high_income.csv").set_index("Unnamed: 0")

# Checking one of the tables

mfad_upper_middle

# Combining MFAD values of each income group
mfad_all_groups = pd.concat([mfad_low_income,
                             mfad_lower_middle,
                             mfad_upper_middle,
                             mfad_high_income], axis=1)

mfad_all_groups.head()

# Renaming the columns in the table above

mfad_all_groups.columns = ["mfad_low_income", "mfad_lower_middle", "mfad_upper_middle", "mfad_high_income"]

mfad_all_groups.tail()

# Melting the frame so that one can do ANOVA on it easily

# Re-indexing the frame
data = mfad_all_groups.iloc[:-1, :].reset_index()


# Melting the frame
melted_data = data.melt(id_vars="Unnamed: 0")

melted_data

# Running ANOVA for the indicator

# Creating and fitting the model
model = ols("value ~ C(variable)", data=melted_data).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Plotting this information

mfad_total = pd.DataFrame(mfad_all_groups.loc["Total"]).sort_values("Total", ascending=False)

fig, ax = plt.subplots()
fig.set_size_inches(6, 4.5)

bar_plotter(x="Total",
            y=mfad_total.index,
            ax=ax,
            df=mfad_total,
            palette="Blues_r",
            xlabel="MFAD values")

plt.show()

mfad_total

# Importing the dataset of median age

median_age = pd.read_csv("median-age.csv")

median_age.head()

# Filtering the data for year 2019

median_age_2019 = median_age[median_age["Year"] == 2019]

median_age_2019.head()

# Filtering only the columns needed and setting index to the column containing countries

median_age_clean = median_age_2019.drop(["Year", "Code", "Median age - Sex: all - Age: all - Variant: medium"], axis=1).set_index("Entity")

median_age_clean.head()

# Combining this dataset and the one that has sizes of economies

median_age_economized = pd.merge(size_of_economy,
                                 median_age_clean,
                                 left_index=True,
                                 right_index=True).drop("Region", axis=1)

median_age_economized.info()

<class 'pandas.core.frame.DataFrame'>
Index: 187 entries, Aruba to Zimbabwe
Data columns (total 2 columns):
 #   Column                                                 Non-Null Count  Dtype  
---  ------                                                 --------------  -----  
 0   Income group                                           187 non-null    object 
 1   Median age - Sex: all - Age: all - Variant: estimates  187 non-null    float64
dtypes: float64(1), object(1)
memory usage: 4.4+ KB

# Grouping the data according to income groups and checking for means and medians.

median_age_mean_values = median_age_economized.groupby("Income group").mean()

display(median_age_mean_values)

median_age_median_values = median_age_economized.groupby("Income group").median()

display(median_age_median_values)

# Using the data above to import the DRI's (Daily Recommended Intakes) (Source cited at the Thesis Report)

nutrients = ["Energy", "Folate", "Niacin", "Panthothenic Acid", "Riboflavin", "Thiamin", "Vitamin A", "Vitamin B12", "Vitamin B6", "Vitamin C", "Vitamin D", "Vitamin E", "Vitamin K", "Calcium", "Copper", "Iron", "Magnesium", "Manganese", "Phosphorus", "Potassium", "Selenium", "Zinc", "Alpha-Linolenic Acid", "Linoleic Acid", "Choline", "Dietary Fiber", "Protein", "Water"]

units = ["kcal", "micrograms", "milligrams", "milligrams", "milligrams", "milligrams", "micrograms", "micrograms", "milligrams", "milligrams", "micrograms", "milligrams", "micrograms", "milligrams", "micrograms", "milligrams", "millgrams", "milligrams", "milligrams", "grams", "micrograms", "milligrams", "grams", "grams", "milligrams", "grams", "gram", "grams"]

units_in_grams = [7.716, 1000000, 1000, 1000, 1000, 1000, 1000000, 1000000, 1000, 1000, 1000000, 1000, 1000000, 1000, 1000000, 1000, 1000, 1000, 1000, 1, 1000000, 1000, 1, 1, 1000, 1, 1, 1]

dri_high_income_male = [2900, 400, 16, 5, 1.3, 1.2, 900, 2.4, 1.3, 90, 5, 15, 120, 1000, 900, 8, 420, 2.3, 700, 4.7, 55, 11, 1.6, 17, 550, 38, 56, 3]
dri_high_income_female = [2200, 400, 14, 5, 1.1, 1.1, 700, 2.4, 1.3, 75, 5, 15, 90, 1000, 900, 18, 320, 1.8, 700, 4.7, 55, 8, 1.6, 17, 425, 25, 46, 2.7]


dri_lower_middle_male = [2900, 400, 16, 5, 1.3, 1.2, 900, 2.4, 1.3, 90, 5, 15, 120, 1000, 900, 8, 420, 2.3, 700, 4.7, 55, 11, 1.6, 17, 550, 38, 56, 3]
dri_lower_middle_female = [2200, 400, 14, 5, 1.1, 1.1, 700, 2.4, 1.3, 75, 5, 15, 90, 1000, 900, 18, 320, 1.8, 700, 4.7, 55, 8, 1.6, 17, 425, 25, 46, 2.7]


dri_upper_middle_male = [2900, 400, 16, 5, 1.3, 1.2, 900, 2.4, 1.3, 90, 5, 15, 120, 1000, 900, 8, 420, 2.3, 700, 4.7, 55, 11, 1.6, 17, 550, 38, 56, 3]
dri_upper_middle_female = [2200, 400, 14, 5, 1.1, 1.1, 700, 2.4, 1.3, 75, 5, 15, 90, 1000, 900, 18, 320, 1.8, 700, 4.7, 55, 8, 1.6, 17, 425, 25,46, 2.7]


dri_low_income_males = [3000, 400, 16, 5, 1.3, 1.2, 900, 2.4, 1.3, 75, 5, 15, 120, 1300, 890, 11, 410, 2.2, 1250, 4.7, 55, 11, 1.6, 16, 550, 38, 52, 2.6]
dri_low_income_females = [2200, 400, 14, 5, 1.0, 1.0, 700, 2.4, 1.2, 65, 5, 15, 90, 1300, 890, 15, 360, 1.6, 1250, 4.7, 55, 9, 1.6, 16, 400, 26, 46, 1.8]

columns = pd.MultiIndex.from_product([["dri_low_income", "dri_lower_middle", "dri_upper_middle", "dri_high_income"], ["male", "female"]])

dri = pd.DataFrame([dri_low_income_males, 
                    dri_low_income_females,
                    dri_lower_middle_male, 
                    dri_lower_middle_female,
                    dri_upper_middle_male, 
                    dri_upper_middle_female,
                    dri_high_income_male, 
                    dri_high_income_female]).T

dri.index = list((nutrients, units))

dri.columns = columns

dri.index.names = ["Nutrient", "Unit"]

# I forgot to represent the units in grams
dri["units_in_one_gram"] = [7.716, 1000000, 1000, 1000, 1000, 1000, 1000000, 1000000, 1000, 1000, 1000000, 1000, 1000000, 1000, 1000000, 1000, 1000, 1000, 1000, 1, 1000000, 1000, 1, 1, 1000, 1, 1, 1]


# Bringing the latest column to the front
columns_dir = list(dri.columns)

new_columns_dir = columns_dir[-1:] + columns_dir[:-1]

new_columns_dir

dri = dri[new_columns_dir]

dri

# Importing the gender ratio table 

gender = pd.read_csv("share-population-female.csv")

gender.head()

# Filtering for year 2019

gender_2019 = gender[gender["Year"] == 2019]

gender_2019.head()

# Removing unwanted columns

gender_filtered = gender_2019.drop(["Code", "Year"], axis=1).set_index("Entity")

gender_filtered.head()

# Adding to it the population numbers

# Importing the population growth table

pop_growth = pd.read_csv("population-and-demography.csv")

pop_growth.head()

# Filtering for 2019

pop_growth_2019 = pop_growth[pop_growth["Year"] == 2019]

pop_growth_2019.head()

# Removing all other columns except "Population" and "Country name"

pop_growth_clean = pop_growth_2019.iloc[:, [0, 2]].set_index("Country name")

pop_growth_clean.head()

# Attaching the table above with the percentage_of_women table

pop_dynamics = pd.merge(gender_filtered,
                        pop_growth_clean,
                        left_index=True,
                        right_index=True)

pop_dynamics

# Loading the Intakes data from the first metric

daily_dietary_intake.head(2)

# Converting the values above into grams

daily_intakes_in_grams = daily_dietary_intake.iloc[:, 1:] / 7.7162

daily_intakes_in_grams.head()

# Putting back the "Income group" column on the table

daily_intakes_in_grams = pd.merge(size_of_economy,
                                 daily_intakes_in_grams,
                                 left_index=True,
                                 right_index=True).drop("Region", axis=1)

daily_intakes_in_grams.head(2)

# Revisiting the Nutrient_composition table

nutrition_table

# Extracting target nutrients

nutrients_for_balance_score = nutrition_table.loc[:, ["Zinc, Zn", "Water", "Energy",
                                                      "Protein", "Fiber, total dietary", "Calcium, Ca",
                                                      "Iron, Fe", "Magnesium, Mg", "Phosphorus, P",
                                                      "Potassium, K", "Copper, Cu", "Manganese, Mn",
                                                      "Selenium, Se", "Vitamin C, total ascorbic acid",
                                                      "Thiamin", "Riboflavin", "Niacin",
                                                      "Pantothenic acid", "Vitamin B-6", "Folate, total",
                                                      "Choline, total", "Vitamin B-12", "Vitamin D", "18:3 n-3 c,c,c (ALA)",
                                                      "18:3 undifferentiated", "Vitamin A, RAE", "Vitamin E (alpha-tocopherol)",
                                                      "Vitamin K (phylloquinone)"]] / 10000 # For converting the values from being per 100g to 1g

nutrients_for_balance_score.head(6)

# Calculating nutrient intakes: Taking medians of the daily_intakes_in_grams

median_daily_intakes_in_grams = daily_intakes_in_grams.groupby("Income group").median()

median_daily_intakes_in_grams

# How many of these nutrients are consumed daily according to the food intakes by grams?


# Calculating nutrient intakes: Modifying the "nutrient_supply" supply

def nutrient_intakes(df) :
    """Calculates nutrient intakes for a particular country or country group"""

    column_names = list(nutrients_for_balance_score.columns.values)

    index_names = list(df.columns.values)

    index_names.remove("Roots & Tubers")

    index_names.remove("Infant food")

    nutrient_intakes = pd.DataFrame([(df["Cereals"].values * nutrients_for_balance_score.loc["Breakfast Cereals"].values),
                                     (df["Seeds, Nuts, and Oils"].values * nutrients_for_balance_score.loc["Seeds, Nuts, and Oils"].values),
                                     (df["Starchs & Sugars"].values * nutrients_for_balance_score.loc["Beverages"].values),
                                     (df["Dairy & Egg Products"].values * nutrients_for_balance_score.loc["Dairy and Egg Products"].values),
                                     (df["Finfish / Shellfish Products"].values * nutrients_for_balance_score.loc["Finfish and Shellfish Products"].values),
                                     (df["Poultry"].values * nutrients_for_balance_score.loc["Poultry Products"].values),
                                     (df["Pork"].values * nutrients_for_balance_score.loc["Pork Products"].values),
                                     (df["Beef Products"].values * nutrients_for_balance_score.loc["Beef Products"].values),
                                     (df["Spices & Herbs"].values * nutrients_for_balance_score.loc["Spices and Herbs"].values),
                                     (df["Legumes & Products"].values * nutrients_for_balance_score.loc["Legumes and Legume Products"].values),
                                     (df["Vegetables"].values * nutrients_for_balance_score.loc["Vegetables and Vegetable Products"].values),
                                     (df["Fruits & Plantains"].values * nutrients_for_balance_score.loc["Fruits and Fruit Juices"].values)])
    
    nutrient_intakes.columns = column_names

    nutrient_intakes.index = index_names
    
    df = nutrient_intakes

    # Multiplying each nutrient with its respective unit
    for column in df :

        if column == "Zinc, Zn" :
            df[column] = df[column] * 1000

        elif column == "Water" :
            df[column] = df[column] * 1


        elif column == "Protein" :
            df[column] = df[column] * 1
            

        elif column == "Fiber, total dietary" :
            df[column] = df[column] * 1

        elif column == "Energy":
            df[column] = df[column] * 7.716


        elif column == "Calcium, Ca" :
            df[column] = df[column] * 1000

        elif column == "Iron, Fe":
            df[column] = df[column] * 1000

        elif column == "Magnesium, Mg":
            df[column] = df[column] * 1000

        elif column == "Phosphorous, P" :
            df[column] = df[column] * 1000

        elif column == "Potassium, K" :
            df[column] = df[column] * 1000

        elif column == "Copper, Cu" :
            df[column] = df[column] * 1000000

        elif column == "Manganese, Mn" :
            df[column] = df[column] * 1000

        elif column == "Selenium, Se" :
            df[column] = df[column] * 1000000

        elif column == "Vitamin C, total ascorbic acid" :
            df[column] == df[column] * 1000

        elif column == "Thiamin" :
            df[column] = df[column] * 1000
            

        elif column == "Riboflavin" :
            df[column] = df[column] * 1000

        elif column == "Niacin" :
            df[column] = df[column] * 1000

        elif column == "Pantothenic acid" :
            df[column] = df[column] * 1000

        elif column == "Vitamin B-6" :
            df[column] = df[column] * 1000

        elif column == "Folate, total" :
            df[column] = df[column] * 1000000

        elif column == "Choline, total" :
            df[column] = df[column] * 1000

        elif column == "Vitamin B-12" :
            df[column] = df[column] * 1000000

        elif column == "Vitamin D" :
            df[column] = df[column] * 1000000


        elif column == "18:3 n-3 c,c,c (ALA)" :
            df[column] = df[column] * 1

        elif column == "18:3 undifferentiated" :
            df[column] = df[column] * 1

        elif column == "Vitamin A, RAE" :
            df[column] = df[column] * 1000000

        elif column == "Vitamin E (alpha-tocopherol)" :
            df[column] = df[column] * 1000

        elif column == "Vitamin K (phylloquinone)" :
            df[column] = df[column] * 1000000
            
    nutrient_intakes.loc["Total"] = nutrient_intakes.iloc[:, :].sum()

    nutrient_intakes.loc["Unit"] = ["milligrams", "grams", "kcal", "grams", "grams", "milligrams", "milligrams", "milligrams", "milligrams", "grams", "micrograms", "milligrams", "micrograms", "milligrams", "milligrams", "milligrams", "milligrams", "milligrams", "milligrams", "micrograms", "milligrams", "micrograms", "micrograms", "grams", "grams", "micrograms", "milligrams", "micrograms"]

    nutrient_intakes = nutrient_intakes.T

    nutrient_intakes.insert(0, "Unit", nutrient_intakes.pop("Unit"))


    nutrient_intakes = nutrient_intakes.reindex(["Energy", "Folate, total", "Niacin", "Pantothenic acid", "Riboflavin", "Thiamin", "Vitamin A, RAE", "Vitamin B-12", "Vitamin B-6", "Vitamin C, total ascorbic acid", "Vitamin D", "Vitamin E (alpha-tocopherol)", "Vitamin K (phylloquinone)", "Calcium, Ca", "Copper, Cu", "Iron, Fe", "Magnesium, Mg", "Manganese, Mn", "Phosphorus, P", "Potassium, K", "Selenium, Se", "Zinc, Zn", "18:3 n-3 c,c,c (ALA)", "18:3 undifferentiated", "Choline, total", "Fiber, total dietary", "Protein", "Water"])
    
    return nutrient_intakes

# Calculating nutrient intakes in grams

nutrient_intakes_low_income = nutrient_intakes(median_daily_intakes_in_grams.loc[["Low income"]])

nutrient_intakes_lower_middle = nutrient_intakes(median_daily_intakes_in_grams.loc[["Lower middle income"]])

nutrient_intakes_upper_middle = nutrient_intakes(median_daily_intakes_in_grams.loc[["Upper middle income"]])

nutrient_intakes_high_income = nutrient_intakes(median_daily_intakes_in_grams.loc[["High income"]])

# Taking a peek of the data.
pd.DataFrame(nutrient_intakes_lower_middle.iloc[:, -1]).T.rename(index={"Total" : "Low income"})

dri

# Calculating the QI score. Making a fuction that will do just that.

def qi_calculator(nut_intakes_table, dri_table, df1_column, df2_column) :
    """Calculating the QI scores from a nutrient intakes table and the dri table"""

    # Taking the target columns
    series_1 = nut_intakes_table[df1_column]

    series_2 = df2_column

    # Preparing the index of each nutrient for the last df
    index = dri.index

    # Calculating the QI itself
    the_energy_part = series_2[0] / series_1[0]

    qi_for_each_nutrient = pd.DataFrame(the_energy_part * (series_1.values / series_2.values), index=index, columns=["qi_score"])

    qi_for_each_nutrient["qi_score_for_nb"] = [(n-n) + 1 if n > 1 else n for n in qi_for_each_nutrient["qi_score"]]

    qi_for_each_nutrient = qi_for_each_nutrient.drop("qi_score", axis=1)

    qi_for_each_nutrient.loc["nb_score_as_percentage"] = (qi_for_each_nutrient["qi_score_for_nb"].mean()) * 100

    return qi_for_each_nutrient

# Calculating the qi score for low income countries
qi_score_male_low_income = qi_calculator(nutrient_intakes_low_income, dri, "Total", dri["dri_low_income", "male"])

qi_score_female_low_income = qi_calculator(nutrient_intakes_low_income, dri, "Total", dri["dri_low_income", "female"])

qi_score_low_income = pd.merge(qi_score_male_low_income,
                               qi_score_female_low_income,
                               left_index=True,
                               right_index=True,
                               suffixes=("_male", "_female"))


# Calculating the same for lower_middle income countries
qi_score_male_lower_middle = qi_calculator(nutrient_intakes_lower_middle, dri, "Total", dri["dri_lower_middle", "male"])

qi_score_female_lower_middle = qi_calculator(nutrient_intakes_lower_middle, dri, "Total", dri["dri_lower_middle", "female"])

qi_score_lower_middle = pd.merge(qi_score_male_lower_middle,
                               qi_score_female_lower_middle,
                               left_index=True,
                               right_index=True,
                               suffixes=("_male", "_female"))


# Calculating also for the upper middle
qi_score_male_upper_middle = qi_calculator(nutrient_intakes_upper_middle, dri, "Total", dri["dri_upper_middle", "male"])

qi_score_female_upper_middle = qi_calculator(nutrient_intakes_upper_middle, dri, "Total", dri["dri_upper_middle", "female"])

qi_score_upper_middle = pd.merge(qi_score_male_upper_middle,
                                 qi_score_female_upper_middle,
                                 left_index=True,
                                 right_index=True,
                                 suffixes=("_male", "_female"))


# Calculating the same for the Hight income
qi_score_male_high_income = qi_calculator(nutrient_intakes_high_income, dri, "Total", dri["dri_high_income", "male"])

qi_score_female_high_income = qi_calculator(nutrient_intakes_high_income, dri, "Total", dri["dri_high_income", "female"])

qi_score_high_income = pd.merge(qi_score_male_high_income,
                                qi_score_female_high_income,
                                left_index=True,
                                right_index=True,
                                suffixes= ("_male", "_female"))


# Merging all tables together
qi_score_all_economies = pd.concat([qi_score_low_income,
                                  qi_score_lower_middle,
                                  qi_score_upper_middle,
                                  qi_score_high_income], axis=1)


# Creating a better index for the table
column_index = pd.MultiIndex.from_product([["low_income", "lower_middle", "upper_middle", "high_income"], ["qi_score_for_nb_male", "qi_score_for_nb_female"]])

qi_score_all_economies.columns = column_index

qi_score_all_economies

# Dissecting the table for male values only
qi_score_all_males = pd.DataFrame(qi_score_all_economies.iloc[-1, [0, 2, 4, 6]])


# Doing the same thing for female values
qi_score_all_females = pd.DataFrame(qi_score_all_economies.iloc[-1, [1, 3, 5, 7]])


# Renaming the columns before
qi_score_all_males.columns = ["nb_score_males"]

qi_score_all_females.columns = ["nb_score_females"]


# Renaming the indeces also
qi_score_all_males.index = ["low income", "lower middle income", "upper middle income", "high income"]

qi_score_all_females.index = ["low income", "lower middle income", "upper middle income", "high income"]

# Concatinating the two tables horizontally
nb_scores_all = pd.concat([qi_score_all_males, qi_score_all_females], axis=1)

nb_scores_all.sort_values(["nb_score_males", "nb_score_females"], ascending=False, inplace=True)

nb_scores_all.to_csv("nutrient_balance_scores_all.csv")

nb_scores_all

# Plotting the information above

sns.barplot(x="nb_score_males",
            y=nb_scores_all.index,
            data=nb_scores_all,
            palette="Blues_r")

plt.show()

sns.barplot(x="nb_score_females",
            y=nb_scores_all.index,
            data=nb_scores_all,
            palette="BuGn")

<Axes: xlabel='nb_score_females'>

# Referring back to the "daily_intakes_in_grams" dataset

daily_intakes_in_grams.head()

# Creating a fuction that'll calculate the coefficients of variation for 8 essential nutrients from the daily food intakes of the table above.

def CoV_calculator(df) :
    """Calculates the coefficients of variance for the nutrient intake values of the 8 essential nutrients as outlined by Gustafson et al (2016)"""

    # Creating a collection point for processed rows of the initial dataframe
    df_collections = []

    # Removing the "Income group" column
    df = df.drop("Income group", axis=1)

    # Processing the rows: Getting the total intake values of each nutrient for each country.
    for index, data in df.iterrows() :
        row_framed = pd.DataFrame(data).T

        row_intakes = nutrient_intakes(row_framed)

        row_intakes_restructured = pd.DataFrame(row_intakes.iloc[:, -1]).T.rename(index={"Total" : index})

        df_collections.append(row_intakes_restructured)

    # Reassembiling the rows into a single df again..
    final_output = pd.concat(df_collections)

    # Putting back the "Income group" column
    final_output_economized = pd.merge(size_of_economy,
                                       final_output,
                                       left_index=True,
                                       right_index=True).drop("Region", axis=1)
    

    # Filtering for only the wanted nutrients.
    final_output_economized_filtered = final_output_economized[["Income group", "Zinc, Zn", "Niacin", "Vitamin B-6", "Calcium, Ca", "Riboflavin", "Folate, total", "Vitamin C, total ascorbic acid", "Vitamin A, RAE"]]


    # Calculating the Coefficients of variation for each country group
    low_income_values = final_output_economized_filtered[final_output_economized_filtered["Income group"] == "Low income"]

    lower_middle_values = final_output_economized_filtered[final_output_economized_filtered["Income group"] == "Lower middle income"]

    upper_middle_values = final_output_economized_filtered[final_output_economized_filtered["Income group"] == "Upper middle income"]

    high_income_values = final_output_economized_filtered[final_output_economized_filtered["Income group"] == "High income"]


    # Creating collection points for rows that are processed for coefficient of variation.
    low_income_coefficients_of_variation = []

    lower_middle_coefficients_of_variation = []

    upper_middle_coefficients_of_variation = []

    high_income_coefficients_of_variation = []


    # Dissecting the "final_output_economized_filtered" table for coefficients of variation
    for row, data in final_output_economized_filtered.iterrows() :
        if data[0] == "Low income" :
            row_framed_2 = pd.DataFrame(data).T

            row_framed_2.loc["Coefficient of Variations"] = (low_income_values.iloc[:, 1:].std() / low_income_values.iloc[:, 1:].mean()) * 100

            row_framed_2.drop(row, inplace=True)

            row_framed_3 = row_framed_2.rename(index={row_framed_2.index[0] : row})

            low_income_coefficients_of_variation.append(row_framed_3)

        elif data[0] == "Lower middle income" :
            row_framed_2 = pd.DataFrame(data).T

            row_framed_2.loc["Coefficient of Variations"] = (lower_middle_values.iloc[:, 1:].std() / lower_middle_values.iloc[:, 1:].mean()) * 100

            row_framed_2.drop(row, inplace=True)

            row_framed_3 = row_framed_2.rename(index={row_framed_2.index[0] : row})

            lower_middle_coefficients_of_variation.append(row_framed_3)

        elif data[0] == "Upper middle income" :
            row_framed_2 = pd.DataFrame(data).T

            row_framed_2.loc["Coefficient of Variations"] = (upper_middle_values.iloc[:, 1:].std() / upper_middle_values.iloc[:, 1].mean()) * 100

            row_framed_2.drop(row, inplace=True)

            row_framed_3 = row_framed_2.rename(index={row_framed_2.index[0] : row})

            upper_middle_coefficients_of_variation.append(row_framed_3)

        else :
            row_framed_2 = pd.DataFrame(data).T

            row_framed_2.loc["Coefficient of Variation"] = (high_income_values.iloc[:, 1:].std() / high_income_values.iloc[:, 1:].mean()) * 100

            row_framed_2.drop(row, inplace=True)

            row_framed_3 = row_framed_2.rename(index={row_framed_2.index[0] : row})

            high_income_coefficients_of_variation.append(row_framed_3)

    
    # Assembling coefficients of variation in their respective income groups
    low_income_coefficients_of_variation = pd.concat(low_income_coefficients_of_variation)

    lower_middle_coefficients_of_variation = pd.concat(lower_middle_coefficients_of_variation)

    upper_middle_coefficients_of_variation = pd.concat(upper_middle_coefficients_of_variation)

    high_income_coefficients_of_variation = pd.concat(high_income_coefficients_of_variation)


    # Assembling coefficients of variation into a single dataset
    coefficients_of_variation = pd.concat([low_income_coefficients_of_variation,
                                            lower_middle_coefficients_of_variation,
                                            upper_middle_coefficients_of_variation,
                                            high_income_coefficients_of_variation])
    

    # Dropping the "Income group" column in the newly created table since it has null values
    coefficients_of_variation_cleaned = coefficients_of_variation.drop("Income group", axis=1)


    # Joining the table above with the size_of_economy table
    coefficients_of_variation_economized = pd.merge(size_of_economy,
                                                    coefficients_of_variation_cleaned,
                                                    left_index=True,
                                                    right_index=True).drop("Region", axis=1)


    return coefficients_of_variation_economized

# Calculating the coefficients of variation from the "daily_intakes_in_grams" table.

coefficients_of_variation = CoV_calculator(daily_intakes_in_grams)

coefficients_of_variation

# Reviewing the datasets

display(calories_from_non_staples)

display(shannon_diversity_median_scaled)

display(mfad_total)

display(nb_scores_all)

# Cleaning up the tables such that all end-up having one column

shannon_diversity_final = shannon_diversity_median_scaled.drop("diversity_indeces", axis=1)

nb_scores_all["Total"] = (nb_scores_all["nb_score_males"] * 0.5) + (nb_scores_all["nb_score_females"] * 0.5)

nb_scores_all_totaled = nb_scores_all[["Total"]]

display(nb_scores_all_totaled)

display(shannon_diversity_final)

# Cleaning up the tables so that they have consistent (case-sensitive) indexes

mfad_total_reindexed = mfad_total.rename(index={"mfad_lower_middle" : "lower middle income", 
                                                "mfad_upper_middle" : "upper middle income", 
                                                "mfad_high_income" : "high income",
                                                "mfad_low_income" : "low income"})

mfad_total_reindexed


shannon_diversity_final = shannon_diversity_final.rename(index= {"High income" : "high income",
                                                                 "Upper middle income" : "upper middle income",
                                                                 "Lower middle income" : "lower middle income",
                                                                 "Low income" : "low income"})

calories_from_non_staples = calories_from_non_staples.rename(index= {"High income" : "high income",
                                                                     "Upper middle income" : "upper middle income",
                                                                     "Lower middle income" : "lower middle income",
                                                                     "Low income" : "low income"})


display(mfad_total_reindexed, shannon_diversity_final, calories_from_non_staples)

# Renaming columns such that columns in all tables have the same name

calories_from_non_staples.columns = ["Total"]

shannon_diversity_final.columns = ["Total"]

display(mfad_total_reindexed, calories_from_non_staples, shannon_diversity_final, nb_scores_all_totaled)

# Creating the function that will calculate the total score

def total_score_calculator(df=[], weights=None) :
    """Calculates the index score for the metric"""

    low_income_frame = []

    lower_middle_frame = []

    upper_middle_frame = []

    high_income_frame = []

    # Selecting the country groups
    for i in df :
        for index, val in i.iterrows() :
            
            if index.__contains__("low income") :

                low_income = pd.DataFrame(val)

                low_income_frame.append(low_income)

            elif index.__contains__("lower") :
                
                lower_middle = pd.DataFrame(val)

                lower_middle_frame.append(lower_middle)

            elif index.__contains__("upper") :
                
                upper_middle = pd.DataFrame(val)

                upper_middle_frame.append(upper_middle)

            else :
                high_income = pd.DataFrame(val)

                high_income_frame.append(high_income)


    # Reassembling frames in each country group
    low_income_framed = pd.concat(low_income_frame)

    upper_middle_framed = pd.concat(upper_middle_frame)

    lower_middle_framed = pd.concat(lower_middle_frame)

    high_income_framed = pd.concat(high_income_frame)


    # Applying the totaling function
    index_score_low_income = pd.DataFrame((low_income_framed["low income"] * weights).sum(), columns=["index_score"], index=["low income"])

    index_score_lower_middle = pd.DataFrame((lower_middle_framed["lower middle income"] * weights).sum(), columns=["index_score"], index=["lower middle income"])

    index_score_upper_middle = pd.DataFrame((upper_middle_framed["upper middle income"] * weights).sum(), columns=["index_score"], index=["upper middle income"])

    index_score_high_income = pd.DataFrame((high_income_framed["high income"] * weights).sum(), columns=["index_score"], index=["high income"])


    # Compiling the 4 tables to have the final output.
    index_scores = pd.concat([index_score_low_income, index_score_lower_middle, index_score_upper_middle, index_score_high_income]).sort_values("index_score", ascending=False)


    # Finishing off the function
    return index_scores

# Calculating the total_score.
index_scores_metric_1 = total_score_calculator(df=[mfad_total_reindexed, nb_scores_all_totaled, shannon_diversity_final, calories_from_non_staples], weights=.25)

index_scores_metric_1.sort_values("index_score", ascending=False, inplace=True)

index_scores_metric_1

# Visualizing the score
fig, ax = plt.subplots()

fig.set_size_inches(6, 5)

sns.barplot(x="index_score",
            y=index_scores_metric_1.index,
            data=index_scores_metric_1,
            palette="Blues_r")

<Axes: xlabel='index_score'>

# Loading the dataset

epi = pd.read_csv("materials_and_methods/Metric_2/indicator_1.csv")

epi.head()

# Removing unwanted columns and resetting the index.

epi_cleaned = epi.iloc[:, [2, 4]].set_index("country")

epi_cleaned.head()

# Joining that data with sizes of economy

epi_economized = pd.merge(size_of_economy,
                          epi_cleaned,
                          left_index=True,
                          right_index=True).drop("Region", axis=1)


epi_economized.head()

# Changing the column names for ANOVA

epi_economized.columns = ["income_group", "epi_new"]

epi_economized.head(2)

# Checking Normality

fig, ax = plt.subplots()

sns.kdeplot(data=epi_economized,
            x= "epi_new",
            hue= "income_group",
            ax=ax,
            palette="seismic_r").set(xlabel="Environmental Performance Index")

plt.show()

# Checking Homoskedasticity

sns.boxplot(x="epi_new",
            y="income_group",
            data=epi_economized)

<Axes: xlabel='epi_new', ylabel='income_group'>

# The data has heteroskedasticity. Applying the log and try to remedy that

epi_transformed = pd.concat([epi_economized, np.log(epi_economized["epi_new"])], axis=1)
                            
epi_transformed


epi_transformed.columns = ["income_group", "epi_new", "epi_transformed"]

epi_transformed

# Plotting the transformed values

sns.boxplot(x="epi_transformed",
            y="income_group",
            data=epi_transformed)

<Axes: xlabel='epi_transformed', ylabel='income_group'>

# The transformation didn't bring better results. Resorting to the original dataset

# Removing the outlier in high incomes

outlier = epi_economized[(epi_economized["income_group"] == "High income") & (epi_economized["epi_new"] < 33)]

outlier

epi_wout_outliers = epi_economized[~epi_economized.isin(outlier)]

# Plotting the data without outliers

sns.boxplot(x="epi_new",
            y="income_group",
            data= epi_wout_outliers)

<Axes: xlabel='epi_new', ylabel='income_group'>

# ANOVA

# Creating and fitting the linear model
model = ols("epi_new ~ C(income_group)", data=epi_economized).fit()

# Accessing ANOVA coefficients
anova_table = sm.stats.anova_lm(model, typ=2)

anova_table

# Summarizing the Data

epi_grouped_by_median = epi_economized.groupby("income_group").median().sort_values("epi_new", ascending=False)

epi_grouped_by_mean = epi_economized.groupby("income_group").mean().sort_values("epi_new", ascending=False)

display(epi_grouped_by_median)
display(epi_grouped_by_mean)

# Visualizing above information in a barplot
fig, ax = plt.subplots()

sns.barplot(data=epi_grouped_by_median,
            x="epi_new",
            y=epi_grouped_by_mean.index,
            ax=ax,
            palette="viridis_r").set_xlabel("Environmental Perfomance Index (0=Worst, 100=Best)")

fig.set_size_inches(6, 2.5)

# Loading the dataset

emissions = pd.read_csv("materials_and_methods/Metric_2/indicator_2.csv")

emissions.head()

# Removing unwanted columns
emissions_only_from_agric = emissions.iloc[:, [0, 2, 7]]

emissions_only_from_agric.head()

# Removing unwanted rows
agricultural_emissions_2019 = emissions_only_from_agric[emissions_only_from_agric["Year"] == 2019].set_index("Entity")#.drop("index", axis=1)

agricultural_emissions_2019.head()

# Filtering Countries to have the same ones as previous tables
emissions_of_sampled_countries = pd.merge(size_of_economy,
                                        agricultural_emissions_2019,
                                        left_index=True,
                                        right_index= True).drop(["Region", "Year"], axis=1)

emissions_of_sampled_countries.head()

# Checking the number of countries we have in the cleaned dataset
emissions_of_sampled_countries.info()

<class 'pandas.core.frame.DataFrame'>
Index: 168 entries, Afghanistan to Zimbabwe
Data columns (total 2 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Income group              168 non-null    object 
 1   Agriculture (per capita)  167 non-null    float64
dtypes: float64(1), object(1)
memory usage: 3.9+ KB

# Dropping the missing value

missing_val = emissions_of_sampled_countries[emissions_of_sampled_countries["Agriculture (per capita)"].isna() == True]

display(missing_val)

emissions_of_sampled_countries = emissions_of_sampled_countries.drop("Liechtenstein")

emissions_of_sampled_countries.info()

<class 'pandas.core.frame.DataFrame'>
Index: 167 entries, Afghanistan to Zimbabwe
Data columns (total 2 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Income group              167 non-null    object 
 1   Agriculture (per capita)  167 non-null    float64
dtypes: float64(1), object(1)
memory usage: 3.9+ KB

# Visualizing the dataset to see if there is normality

sns.kdeplot(x="Agriculture (per capita)",
            hue="Income group",
            data=emissions_of_sampled_countries,
            cut=0)

<Axes: xlabel='Agriculture (per capita)', ylabel='Density'>

# It seems there's an issue with normality. Checking extreme values

sns.boxplot(data=emissions_of_sampled_countries,
            x="Agriculture (per capita)",
            y="Income group")

<Axes: xlabel='Agriculture (per capita)', ylabel='Income group'>

# Removing the outliers: 1. Separating income groups

emissions_high_income = emissions_of_sampled_countries[emissions_of_sampled_countries["Income group"] == "High income"]

emissions_low_income = emissions_of_sampled_countries[emissions_of_sampled_countries["Income group"] == "Low income"]

emissions_lower_middle = emissions_of_sampled_countries[emissions_of_sampled_countries["Income group"] == "Lower middle income"]

emissions_upper_middle = emissions_of_sampled_countries[emissions_of_sampled_countries["Income group"] == "Upper middle income"]

# Removing the outliers

emissions_high_income = emissions_high_income[emissions_high_income["Agriculture (per capita)"] < 4]

emissions_low_income = emissions_low_income[emissions_low_income["Agriculture (per capita)"] < 3]

emissions_lower_middle = emissions_lower_middle[emissions_lower_middle["Agriculture (per capita)"] < 2]

emissions_upper_middle = emissions_upper_middle[emissions_upper_middle["Agriculture (per capita)"] < 1.5]

# Combining the new data and visualizing it

emissions_wout_outliers = pd.concat([emissions_high_income,
                                     emissions_upper_middle,
                                     emissions_lower_middle,
                                     emissions_low_income])


sns.boxplot(x="Agriculture (per capita)",
            y="Income group",
            data=emissions_wout_outliers)

<Axes: xlabel='Agriculture (per capita)', ylabel='Income group'>

# The distribution is way better. Plotting for normality

sns.kdeplot(x="Agriculture (per capita)",
            hue="Income group",
            data=emissions_wout_outliers,
            cut=-0.3)

<Axes: xlabel='Agriculture (per capita)', ylabel='Density'>

# We dealth with normality to some extent. Running ANOVA: 

# Renaming columns to make them proper for ANOVA:
emissions_wout_outliers.columns = ["income_group", "data"]

emissions_wout_outliers.head()

# ANOVA

# Creating and fitting the linear model
model = ols("data ~ C(income_group)", data=emissions_wout_outliers).fit()

# Accessing ANOVA coefficients
anova_table = sm.stats.anova_lm(model, typ=2)

anova_table

# Scaling the dataset to check perfomance
scaled_emissions_total = scaler(emissions_wout_outliers, column="data")

scaled_emissions_total

# Running the ANOVA again to see if the income group had influence on performance

# Renaming the columns of the new data
scaled_emissions_total.columns = ["income_group", "actual_data", "scaled_values"]

# Running the ANOVA
model = ols("scaled_values ~ C(income_group)", data=scaled_emissions_total).fit()

anova_table = sm.stats.anova_lm(model, typ=2)

anova_table

# Still no statistical significance btn the two aspects. Moving on to visualizing the data.

# Plotting the data on a KDE 
fig, ax = plt.subplots()
fig.set_size_inches(7,5)

sns.boxplot(data=scaled_emissions_total,
            x= "scaled_values",
            y= "income_group",
            ax=ax,
            palette="tab10").set(xlabel="0-100 Performance index (0 = Worst, 100 = Best)")

plt.show()

# Descriptive Statistics for each group

scaled_emissions_median = scaled_emissions_total.groupby("income_group").median().sort_values("scaled_values", ascending=False)

display(scaled_emissions_median)

scaled_emissions_mean = scaled_emissions_total.groupby("income_group").mean().sort_values("scaled_values", ascending=False)

display(scaled_emissions_mean)

scaled_emissions_count = scaled_emissions_total.groupby("income_group").count()

scaled_emissions_count

# Visualizing the medians in a bargraph

df = scaled_emissions_median
fig, ax = plt.subplots()

sns.barplot(data=df,
            x="scaled_values",
            y=df.index,
            palette="viridis_r").set_xlabel("Per Capita GHG emissions from Agriculture (0-Worst, 100=Best)")

fig.set_size_inches(6, 2.5)

# Loading the dataset

water_withdrawals = pd.read_csv("materials_and_methods/Metric_2/indicator_3.csv")

water_withdrawals.head()

# Removing unwanted columns

water_withdrawals_cleaned = water_withdrawals.iloc[:, [0, 2, 3]]

water_withdrawals_cleaned.head()

# Removing Unwanted Years

water_withdrawals_filtered = water_withdrawals_cleaned[water_withdrawals_cleaned["Year"] == 2019]

water_withdrawals_filtered.head()

# Reseting the index

water_withdrawals_filtered_cleaned = water_withdrawals_filtered.set_index("Entity")

water_withdrawals_filtered_cleaned.head()

# Merging the table above with size_of_economy table

water_withdrawals_economized = pd.merge(size_of_economy,
                                        water_withdrawals_filtered_cleaned,
                                        left_index=True,
                                        right_index= True).drop(["Region", "Year"], axis=1)

water_withdrawals_economized.head()

water_withdrawals_economized.columns = ["income_groups", "agri_percentage"]

water_withdrawals_economized.head()

# Checking Normality in the data

sns.kdeplot(x="agri_percentage",
            hue="income_groups",
            data=water_withdrawals_economized,
            cut=0)

<Axes: xlabel='agri_percentage', ylabel='Density'>

# There's a lot of non-normality in this data. Checking for outliers

sns.boxplot(x="agri_percentage",
            y="income_groups",
            data=water_withdrawals_economized)

<Axes: xlabel='agri_percentage', ylabel='income_groups'>

# Removing the outliers: 1. Separating the Income groups

withdrawals_low_income = water_withdrawals_economized[water_withdrawals_economized["income_groups"] == "Low income"]

withdrawals_lower_middle = water_withdrawals_economized[water_withdrawals_economized["income_groups"] == "Lower middle income"]

withdrawals_upper_middle = water_withdrawals_economized[water_withdrawals_economized["income_groups"] == "Upper middle income"]

withdrawals_high_income = water_withdrawals_economized[water_withdrawals_economized["income_groups"] == "High income"]



# Removing the outlier
withdrawals_lower_middle = withdrawals_lower_middle[withdrawals_lower_middle["agri_percentage"] > 40]

withdrawals_high_income = withdrawals_high_income[withdrawals_high_income["agri_percentage"] < 60]


# Piecing the table back together.
withdrawals_wout_outliers = pd.concat([withdrawals_high_income,
                                      withdrawals_upper_middle,
                                      withdrawals_lower_middle,
                                      withdrawals_low_income])



# Visualizing it now

sns.boxplot(data=withdrawals_wout_outliers,
            x="agri_percentage",
            y="income_groups")

<Axes: xlabel='agri_percentage', ylabel='income_groups'>

# Checking KDE distributions now

sns.kdeplot(data=withdrawals_wout_outliers,
            x="agri_percentage",
            hue="income_groups",
            cut=0,
            palette="seismic").set(xlabel="Percent of Per Capita Water Withdrawals For Agriculture")

[Text(0.5, 0, 'Percent of Per Capita Water Withdrawals For Agriculture')]

# This is more tolerable: Moving on with ANOVA

# Checking number of countries in the dataset

withdrawals_counted = withdrawals_wout_outliers.groupby("income_groups").count()

withdrawals_counted

# The number is tolerable. Modelling and fitting the ANOVA.

# Creating and fitting the linear model
model = ols("agri_percentage ~ C(income_groups)", data=withdrawals_wout_outliers).fit()

# Accessing ANOVA coefficients
anova_table = sm.stats.anova_lm(model, typ=2)

anova_table

# Scaling the data to get performance

withdrawals_wout_outliers = scaler(withdrawals_wout_outliers, column="agri_percentage")

withdrawals_wout_outliers

# Moving on to check means and medians

withdrawals_grouped_by_means = withdrawals_wout_outliers.groupby("income_groups").mean()

withdrawals_grouped_by_medians = withdrawals_wout_outliers.groupby("income_groups").median().sort_values("agri_percentage", ascending=False)

display(withdrawals_grouped_by_means)
display(withdrawals_grouped_by_medians)

# Plotting the information above

df = withdrawals_grouped_by_medians.sort_values("agri_percentage", ascending=False)

fig, ax = plt.subplots()

fig.set_size_inches(6, 3)

sns.barplot(x="agri_percentage",
            y=df.index,
            data=df,
            palette="viridis").set(xlabel="Per Capita Water Withdrawals For Agriculture (%)",
                                   ylabel="Income groups")

[Text(0.5, 0, 'Per Capita Water Withdrawals For Agriculture (%)'),
 Text(0, 0.5, 'Income groups')]

# Importing the datasets

coal = pd.read_csv("materials_and_methods/Metric_2/energy_use/coal.csv")
display(coal.head(2))

natural_gas = pd.read_csv("materials_and_methods/Metric_2/energy_use/natural_gas.csv")
display(natural_gas.head(2))

petrol = pd.read_csv("materials_and_methods/Metric_2/energy_use/petroleum.csv")
display(petrol.head(2))

population_data = pd.read_csv("materials_and_methods/Metric_2/energy_use/population.csv")
display(population_data.head(2))

# Filtering for the needed year, removing unwanted columns, and putting a multiindex on columns

cleaned_coal = coal[coal["Year"] == 2019].iloc[:, [3, 7, 11]]

cleaned_coal.head()

coal_pivoted = cleaned_coal.pivot_table(index="Area",
                                      columns="Item",
                                      values="Value").iloc[:, [6]]


columns = pd.MultiIndex.from_product([["Coal"], list(coal_pivoted.columns.values)])

coal_pivoted.columns = columns

coal_pivoted.head()

cleaned_gas = natural_gas[natural_gas["Year"] == 2019].iloc[:, [3, 7, 11]]

cleaned_gas.head()

gas_pivoted = cleaned_gas.pivot_table(index="Area", columns="Item", values="Value").iloc[:, [6]]

columns = pd.MultiIndex.from_product([["natural_gas"], list(gas_pivoted.columns.values)])

gas_pivoted.columns = columns

gas_pivoted.head()

cleaned_petrol = petrol[petrol["Year"] == 2019].iloc[:, [3, 7, 11]]

cleaned_petrol.head()

petrol_pivoted = cleaned_petrol.pivot_table(index="Area", columns="Item", values="Value").iloc[:, [6]]

columns = pd.MultiIndex.from_product([["petrol"], list(petrol_pivoted.columns.values)])

petrol_pivoted.columns = columns

petrol_pivoted.head()

clean_population = population_data[(population_data["Year"] == 2019) \
                                   & \
                                   (population_data["Flag Description"] == "Figure from international organizations")].iloc[:, [3, 11]].set_index("Area")

clean_population.head()


# Putting the value in its correct notation
clean_population["Value"] = clean_population["Value"] * 1000


# Making two levels so that when the table is combined with other tables it doesn't create problems.
columns = pd.MultiIndex.from_product([["Total Population"], list(clean_population.columns.values)])

clean_population.columns = columns

clean_population

# Combining the 4 tables to get the total energy from Agriculture + Total population

coal_and_gas = pd.merge(coal_pivoted,
                        gas_pivoted,
                        how="outer",
                        left_on=coal_pivoted.index,
                        right_on=gas_pivoted.index)

coal_and_gas.head()

energy_total = pd.merge(coal_and_gas,
                        petrol_pivoted,
                        how="outer",
                        left_on= "key_0",
                        right_on=petrol_pivoted.index)

energy_total = energy_total.set_index("key_0").fillna(0)

# Putting a column of the total energy from these non-renewable sources as used in agriculture

total_energy_from_agri = energy_total["Coal"] + energy_total["natural_gas"] + energy_total["petrol"]

total_energy_from_agri.head()

# Setting this table to have two levels and then merging it with the energy_total table

columns = pd.MultiIndex.from_product([["total_energy_used_from_agri"], ["value"]])

total_energy_from_agri.columns = columns

total_energy_from_agri.head(2)


# doing the merger

energies_summed = pd.merge(energy_total,
                           total_energy_from_agri,
                           left_index=True,
                           right_index=True)

energies_summed.info()

<class 'pandas.core.frame.DataFrame'>
Index: 261 entries, Africa to Yemen
Data columns (total 4 columns):
 #   Column                                    Non-Null Count  Dtype  
---  ------                                    --------------  -----  
 0   (Coal, Pre- and Post- Production)         261 non-null    float64
 1   (natural_gas, Pre- and Post- Production)  261 non-null    float64
 2   (petrol, Pre- and Post- Production)       261 non-null    float64
 3   (total_energy_used_from_agri, value)      261 non-null    float64
dtypes: float64(4)
memory usage: 18.3+ KB

# Combining the table above with the population table
energy_and_pop_size = pd.merge(energies_summed,
                               clean_population,
                               left_index=True,
                               right_index=True)

energy_and_pop_size.info()

<class 'pandas.core.frame.DataFrame'>
Index: 219 entries, Africa to Yemen
Data columns (total 5 columns):
 #   Column                                    Non-Null Count  Dtype  
---  ------                                    --------------  -----  
 0   (Coal, Pre- and Post- Production)         219 non-null    float64
 1   (natural_gas, Pre- and Post- Production)  219 non-null    float64
 2   (petrol, Pre- and Post- Production)       219 non-null    float64
 3   (total_energy_used_from_agri, value)      219 non-null    float64
 4   (Total Population, Value)                 219 non-null    float64
dtypes: float64(5)
memory usage: 10.3+ KB

# Calculating per capita energy use from these three energy sources

energy_per_capita = pd.DataFrame(list(energy_and_pop_size["total_energy_used_from_agri"].values / energy_and_pop_size["Total Population"].values), 
                                 columns=["energy_per_capita"],
                                 index=energy_and_pop_size.index)

energy_per_capita.info()

<class 'pandas.core.frame.DataFrame'>
Index: 219 entries, Africa to Yemen
Data columns (total 1 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   energy_per_capita  219 non-null    float64
dtypes: float64(1)
memory usage: 3.4+ KB

# Merging the previous table with the size_of_economy table

per_capita_energy_economized = pd.merge(size_of_economy,
                                        energy_per_capita,
                                        left_index=True,
                                        right_index=True).drop("Region", axis=1)

per_capita_energy_economized.info()

<class 'pandas.core.frame.DataFrame'>
Index: 155 entries, Afghanistan to Zimbabwe
Data columns (total 2 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   Income group       155 non-null    object 
 1   energy_per_capita  155 non-null    float64
dtypes: float64(1), object(1)
memory usage: 3.6+ KB

# Checking the sample size for different income groups

per_capita_energy_economized.groupby("Income group").count()

# Rechecking the table again (It was a good job done above!!)

per_capita_energy_economized.head()

# Renaming columns for ANOVA

per_capita_energy_economized.columns = ["income_group", "energy_per_capita"]

per_capita_energy_economized.head()

# Separating the income groups so that we can scale the data.

low_income_per_capita_energy = per_capita_energy_economized[per_capita_energy_economized["income_group"] == "Low income"]

lower_middle_per_capita_energy = per_capita_energy_economized[per_capita_energy_economized["income_group"] == "Lower middle income"]

upper_middle_per_capita_energy = per_capita_energy_economized[per_capita_energy_economized["income_group"] == "Upper middle income"]

high_income_per_capita_energy = per_capita_energy_economized[per_capita_energy_economized["income_group"] == "High income"]



# Scaling the data

scaled_low_income_energy = scaler(low_income_per_capita_energy, "energy_per_capita")

scaled_lower_middle_energy = scaler(lower_middle_per_capita_energy, "energy_per_capita")

scaled_upper_middle_energy = scaler(upper_middle_per_capita_energy, "energy_per_capita")

scaled_high_income_energy = scaler(high_income_per_capita_energy, "energy_per_capita")

/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values
/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values

# Combining the scaled data

scaled_per_capita_energy = pd.concat([scaled_low_income_energy,
                                      scaled_lower_middle_energy,
                                      scaled_upper_middle_energy,
                                      scaled_high_income_energy])


scaled_per_capita_energy.head()

# Renaming the dataset so that the new column can be used to calculate ANOVA

scaled_per_capita_energy.columns = ["income_group", "energy_per_capita", "scaled_values"]

scaled_per_capita_energy.head()

# Visualizing the dataset to check normality

sns.kdeplot(x="scaled_values",
            hue="income_group",
            data=scaled_per_capita_energy,
            palette="seismic_r")

<Axes: xlabel='scaled_values', ylabel='Density'>

# There seems to be outliers. Fishing them out.

sns.boxplot(data=scaled_per_capita_energy,
            x="scaled_values",
            y="income_group")

<Axes: xlabel='scaled_values', ylabel='income_group'>

# Removing the outliers

outliers_upper_middle_energy = scaled_per_capita_energy[(scaled_per_capita_energy["income_group"] == "Upper middle income") \
                                                       & \
                                                        (scaled_per_capita_energy["scaled_values"] < 20)].index.values

outliers_high_income_energy = scaled_per_capita_energy[(scaled_per_capita_energy["income_group"] == "High income") & \
                                                      (scaled_per_capita_energy["scaled_values"] < 23)].index.values

display(outliers_upper_middle_energy)
display(outliers_high_income_energy)

array(['Kazakhstan', 'Russian Federation', 'Turkmenistan'], dtype=object)

array(['Canada', 'Luxembourg', 'Oman', 'Qatar'], dtype=object)

# Removing the outliers

scaled_per_capita_energy = scaled_per_capita_energy.drop(['Kazakhstan', 'Russian Federation', 'Turkmenistan', 'Canada', 'Luxembourg', 'Oman', 'Qatar'])

# Plotting the kdeplot again

sns.kdeplot(data=scaled_per_capita_energy,
            x="scaled_values",
            hue="income_group",
            palette="seismic",
            cut=0).set_xlabel("Performance on Energy Per Capita From Agriculture (0=Worse, 100=Best)")

Text(0.5, 0, 'Performance on Energy Per Capita From Agriculture (0=Worse, 100=Best)')

sns.boxplot(data=scaled_per_capita_energy,
            x="scaled_values",
            y="income_group")

<Axes: xlabel='scaled_values', ylabel='income_group'>

# There is still a right skewing of the data. Applying a natural log to see if we can deal with that problem.

scaled_per_capita_energy.head()

scaled_per_capita_energy["log_scaled"] = np.log(scaled_per_capita_energy["energy_per_capita"])

scaled_per_capita_energy.head()

# Visualizing the log scaled values

sns.kdeplot(data= scaled_per_capita_energy,
            x= "energy_per_capita",
            hue= "income_group",
            palette="seismic",
            cut=0)

<Axes: xlabel='energy_per_capita', ylabel='Density'>

# Rescaling the data such that the actual data is represented as percentages. This will make the data more meaningful when comparing.
scaled_per_capita_energy["energy_per_capita"] = scaled_per_capita_energy["energy_per_capita"] * 10000

# Rescaling the values into the 0-100 performance scale
scaled_per_capita_energy = scaler(scaled_per_capita_energy[["income_group", "energy_per_capita"]], column="energy_per_capita")

scaled_per_capita_energy

/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values

# The resulting dataset is more meaningful. Moving on to ANOVA.

# The model

model = ols("energy_per_capita ~ C(income_group)", data=scaled_per_capita_energy).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# It seems using the scaler on the log_scaled column brings false representation of the energy used. Working with the old scaled values

# Using median to group the dataset

per_capita_energy_by_median = scaled_per_capita_energy.groupby("income_group").median().sort_values("energy_per_capita", ascending=False)

# per_capita_energy_by_median["energy_per_capita"] = per_capita_energy_by_median["energy_per_capita"] * 1

per_capita_energy_by_median

# It seems using medians from scaled_values gives a distorted picture. Using the actual data
fig, ax = plt.subplots()

fig.set_size_inches(6, 4)

sns.barplot(data=per_capita_energy_by_median,
            x="energy_per_capita",
            y=per_capita_energy_by_median.index,
            palette="viridis").set_xlabel("Energy Per Capita Used in Pre and Post Agriculture (in MegaJoules)")

Text(0.5, 0, 'Energy Per Capita Used in Pre and Post Agriculture (in MegaJoules)')

# Importing the dataset

land_use = pd.read_csv("materials_and_methods/Metric_2/indicator_5.csv")

land_use.head()

# Selecting the relevant year

land_use_filtered = land_use[land_use["Year"] == 2019]

land_use_filtered.head()

# Removing columns that are not wanted.

land_use_cleaned = land_use_filtered.drop(["Code", "Year"], axis=1)

land_use_cleaned.head()

# Re-indexing the dataframe

land_use_completely_cleaned = land_use_cleaned.set_index("Entity").rename_axis("Country")

land_use_completely_cleaned.head()

# Joining the table with sizes of economies

land_use_economized = pd.merge(size_of_economy,
                               land_use_completely_cleaned,
                               left_index=True,
                               right_index=True).drop("Region", axis=1)

land_use_economized.head()

# Renaming the columns for ANOVA
land_use_economized.columns = ["income_group", "hectares_per_capita"]

land_use_economized.head()

# Visualizing the data to check for normality

sns.kdeplot(data=land_use_economized,
            x="hectares_per_capita",
            hue="income_group",
            palette="seismic",
            cut=0)

<Axes: xlabel='hectares_per_capita', ylabel='Density'>

# It looks like we have some outliers lurking around. Checking to confirm.

sns.boxplot(data=land_use_economized,
            x="hectares_per_capita",
            y="income_group")

<Axes: xlabel='hectares_per_capita', ylabel='income_group'>

# Cleaning the outliers

high_income_land_use_wout_outliers = land_use_economized[(land_use_economized["income_group"] == "High income") & \
                                                         (land_use_economized["hectares_per_capita"] < 0.6)]

lower_middle_land_use_wout_outliers = land_use_economized[(land_use_economized["income_group"] == "Lower middle income") & \
                                                          (land_use_economized["hectares_per_capita"] < 1.6)]

upper_middle_land_use_wout_outliers = land_use_economized[(land_use_economized["income_group"] =="Upper middle income") & \
                                                          (land_use_economized["hectares_per_capita"] < 1.5)]

low_income_land_use = land_use_economized[land_use_economized["income_group"] == "Low income"]

# Combining the tables 

total_land_use_wout_outliers = pd.concat([low_income_land_use,
                                          high_income_land_use_wout_outliers,
                                          lower_middle_land_use_wout_outliers,
                                          upper_middle_land_use_wout_outliers])

total_land_use_wout_outliers.head()

# Visualizing outliers again 

sns.boxplot(data=total_land_use_wout_outliers,
            x="hectares_per_capita",
            y="income_group")

<Axes: xlabel='hectares_per_capita', ylabel='income_group'>

# Creating and fitting the model
model = ols("hectares_per_capita ~ C(income_group)", data = total_land_use_wout_outliers).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Scaling the data

total_land_use_scaled = scaler(total_land_use_wout_outliers, column="hectares_per_capita")

total_land_use_scaled

# Exploratory Data Analysis

land_use_grouped_mean = total_land_use_scaled.groupby("income_group").mean().sort_values("Scaled Values", ascending=False)

display(land_use_grouped_mean)

land_use_grouped_median = total_land_use_scaled.groupby("income_group").median().sort_values("Scaled Values", ascending=False)

display(land_use_grouped_median)

land_use_counted = total_land_use_scaled.groupby("income_group").count()

display(land_use_counted)

# Visualizing medians
df = land_use_grouped_median.sort_values("hectares_per_capita", ascending=False)

fig, ax = plt.subplots()
fig.set_size_inches(6, 4)

sns.barplot(data=df,
            x="hectares_per_capita",
            y=df.index,
            palette="viridis").set_xlabel("Hectares per capita")

Text(0.5, 0, 'Hectares per capita')

# Loading the required datasets
display(land_use_grouped_median, per_capita_energy_by_median, withdrawals_grouped_by_medians, scaled_emissions_median, epi_grouped_by_median)

# Cleaning the tables so that they can be worked on by the totalling function

# Re-indexing the names to start with low-cases
land_use_grouped_median = land_use_grouped_median.rename(index={"High income" : "high income",
                                                                "Upper middle income" : "upper middle income",
                                                                "Lower middle income" : "lower middle income",
                                                                "Low income" : "low income"})

per_capita_energy_by_median = per_capita_energy_by_median.rename(index={"High income" : "high income",
                                                                        "Upper middle income" : "upper middle income",
                                                                        "Lower middle income" : "lower middle income",
                                                                        "Low income" : "low income"})

withdrawals_grouped_by_medians = withdrawals_grouped_by_medians.rename(index={"High income" : "high income",
                                                                              "Upper middle income" : "upper middle income",
                                                                              "Lower middle income" : "lower middle income",
                                                                              "Low income" : "low income"})

scaled_emissions_median = scaled_emissions_mean.rename(index={"High income" : "high income",
                                                            "Upper middle income" : "upper middle income",
                                                            "Lower middle income" : "lower middle income",
                                                            "Low income" : "low income"})

epi_grouped_by_median = epi_grouped_by_median.rename(index={"High income" : "high income",
                                                            "Upper middle income" : "upper middle income",
                                                            "Lower middle income" : "lower middle income",
                                                            "Low income" : "low income"})


# Filtering columns such that we have only one column in each table.
land_use_grouped_medians_and_filtered = land_use_grouped_median[["Scaled Values"]]

per_capita_energy_by_median_filtered = per_capita_energy_by_median[["Scaled Values"]].sort_values("Scaled Values", ascending=False)

withdrawals_grouped_by_medians_and_filtered = withdrawals_grouped_by_medians[["Scaled Values"]].sort_values("Scaled Values", ascending=False)

scaled_emissions_median_filtered = scaled_emissions_median[["scaled_values"]]


# Peeking on the data

display(land_use_grouped_medians_and_filtered,
        per_capita_energy_by_median_filtered,
        withdrawals_grouped_by_medians_and_filtered,
        scaled_emissions_median_filtered,
        epi_grouped_by_median)

# Calculating the total metric score

metric_2_scores = total_score_calculator([land_use_grouped_medians_and_filtered,
                                          per_capita_energy_by_median_filtered,
                                          withdrawals_grouped_by_medians_and_filtered,
                                          scaled_emissions_median_filtered,
                                          epi_grouped_by_median],
                                          weights=0.2)

metric_2_scores.sort_values("index_score", ascending=False, inplace=True)

metric_2_scores

# Visualizing the information above

fig, ax = plt.subplots()

fig.set_size_inches(6, 5)

sns.barplot(x="index_score",
            y=metric_2_scores.index,
            data=metric_2_scores,
            palette="Greens_r")

<Axes: xlabel='index_score'>

# Loading the dataset

affordability = pd.read_csv("materials_and_methods/Metric_3/indicator_1.csv", header=None)

affordability.head()

# Resetting the index and renaming columns

affordability_cleaned = affordability.rename(columns={0: "Countries", 1: "Affordability Scores"}).set_index("Countries")

affordability_cleaned

# Attaching that table with size of economies

affordability_economized = pd.merge(size_of_economy,
                                    affordability_cleaned,
                                    left_index=True,
                                    right_index=True).drop("Region", axis=1)

affordability_economized

# Exploratory Data Analysis: Checking the sample size for each country group

affordability_income_groups_counted = affordability_economized.groupby("Income group").count()

display(affordability_income_groups_counted)

# Exploratory Data Analysis: Mean and Median values in each country group

affordability_grouped_by_mean = affordability_economized.groupby("Income group").mean()

display(affordability_grouped_by_mean)

affordability_grouped_by_median = affordability_economized.groupby("Income group").median().sort_values("Affordability Scores", ascending=False)

display(affordability_grouped_by_median)

# Visualizing median values

df = affordability_grouped_by_median

fig, ax = plt.subplots()

fig.set_size_inches(6, 3.8)

sns.barplot(data= df,
            x = "Affordability Scores",
            y = df.index,
            palette= "viridis_r")

<Axes: xlabel='Affordability Scores', ylabel='Income group'>

# Checking for normality

sns.kdeplot(data=affordability_economized,
            x="Affordability Scores",
            hue="Income group")

<Axes: xlabel='Affordability Scores', ylabel='Density'>

# Checking for outliers

sns.boxplot(data = affordability_economized,
            x = "Affordability Scores",
            y = "Income group")

<Axes: xlabel='Affordability Scores', ylabel='Income group'>

# Removing outliers

high_income_affordability_wout_outliers = affordability_economized[(affordability_economized["Income group"] == "High income") & \
                                                                   (affordability_economized["Affordability Scores"] > 84)]

sns.boxplot(data=high_income_affordability_wout_outliers,
            x="Affordability Scores",
            y="Income group")

<Axes: xlabel='Affordability Scores', ylabel='Income group'>

# Creating a complete table wout outliers

low_income_affordability = affordability_economized[affordability_economized["Income group"] == "Low income"]

lower_middle_affordability = affordability_economized[affordability_economized["Income group"] == "Lower middle income"]

upper_middle_affordability = affordability_economized[affordability_economized["Income group"] == "Upper middle income"]


affordability_wout_outliers = pd.concat([low_income_affordability,
                                         lower_middle_affordability,
                                         upper_middle_affordability,
                                         high_income_affordability_wout_outliers])

# Checking for normality again

sns.kdeplot(data = affordability_wout_outliers,
            x= "Affordability Scores",
            hue= "Income group")

<Axes: xlabel='Affordability Scores', ylabel='Density'>

# Transforming the data for normality

affordability_economized["transformed_values"] = np.log(affordability_economized["Affordability Scores"])

affordability_economized.head()

# Checking normality again 

sns.kdeplot(data=affordability_economized,
            x="transformed_values",
            hue="Income group")

<Axes: xlabel='transformed_values', ylabel='Density'>

# Renaming the columns for ANOVA

affordability_economized.columns = ["income_group", "affordability_score", "transformed_values"]

affordability_economized.head()

# Running ANOVA 

# Creating and fitting the model

model = ols("affordability_score ~ C(income_group)", data = affordability_economized).fit()

anova = sm.stats.anova_lm(model, typ = 2)

anova

# Loading the dataset:

food_availability = pd.read_csv("materials_and_methods/Metric_3/indicator_2.csv", header=None)

food_availability.head()

# Renaming columns and resetting the index

availability_cleaned = food_availability.rename({0: "Countries", 1: "Availability Scores"}, axis="columns").set_index("Countries")

availability_cleaned.head()

# Joining the dataset with the size_of_economy dataset

availability_economized = pd.merge(size_of_economy,
                                   availability_cleaned,
                                   right_index=True,
                                   left_index=True).drop("Region", axis=1)

availability_economized.head()

# Checking the normality of the data

sns.kdeplot(data=availability_economized,
            x="Availability Scores",
            hue="Income group",
            palette="seismic")

<Axes: xlabel='Availability Scores', ylabel='Density'>

# It seems like there's a problem in low income countries. Checking for outliers.

sns.boxplot(data=availability_economized,
            x="Availability Scores",
            y="Income group")

<Axes: xlabel='Availability Scores', ylabel='Income group'>

# It seems the problem with normality is a result of skewness. Leaving this for now, running the ANOVA.

# Converting column names such that one can run ANOVA on them.

availability_economized.columns = ["income_group", "availability_scores"]


# Creating and fitting the ANOVA model
model = ols("availability_scores ~ C(income_group)", data=availability_economized).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# It seems ANOVA doesn't have any issue with the data. Moving on to exploratory data analysis: checking the sample size from each income group

availability_group_count = availability_economized.groupby("income_group").count()

availability_group_count

# Exploratory Data Analysis: Checking the mean and median values from each income group

availability_groups_by_mean = availability_economized.groupby("income_group").mean().sort_values("availability_scores", ascending=False)

display(availability_groups_by_mean)

availability_groups_by_median = availability_economized.groupby("income_group").median().sort_values("availability_scores", ascending=False)

display(availability_groups_by_median)

# Plotting the information above

fig, ax = plt.subplots()

fig.set_size_inches(6, 3)

sns.barplot(data=availability_groups_by_median,
            x="availability_scores",
            y=availability_groups_by_median.index,
            palette="viridis_r").set_xlabel("Availability Scores (0=Worst, 100=Best)")

Text(0.5, 0, 'Availability Scores (0=Worst, 100=Best)')

# Importing the data

poverty = pd.read_csv("materials_and_methods/Metric_3/indicator_3.csv")

poverty.head()

# Cleaning the data: Removing unwanted columns (Opening the document in excel and checking columns there helps)

poverty_shortened = poverty.iloc[:, :13]

poverty_shortened

# Taking only rows whose data in the "Sex" column is BOTHSEX, "Age" is ALLAGE, Location is ALLAREA

poverty_1 = poverty_shortened[poverty_shortened["Sex"] == "BOTHSEX"]

poverty_2 = poverty_1[poverty_1["Age"] == "ALLAGE"]

poverty_fully_filtered = poverty_2[poverty_2["Location"] == "ALLAREA"]

poverty_fully_filtered

# Removing all other unwanted columns

poverty_cleaned = poverty_fully_filtered.iloc[:, [6, 12]].set_index("GeoAreaName")

poverty_cleaned

# Attaching it with the size of economy table

poverty_economized = pd.merge(size_of_economy,
                              poverty_cleaned,
                              left_index=True,
                              right_index=True).drop("Region", axis=1)

poverty_economized

# Grouping to check the sample size

poverty_grouped_and_counted = poverty_economized.groupby("Income group").count()
display(poverty_grouped_and_counted)

# Rechecking the initial country names to see if we can salvage low income countries from the initial poverty table

included_names = list(poverty_economized.index.values)

excluded_names = ~poverty_cleaned.index.isin(included_names)

poverty_excluded_values = poverty_cleaned[excluded_names]

poverty_excluded_values

# Checking the median values of low-income countries to see if they reflect the "Least Developed Countries" values given at the poverty table

poverty_grouped_medians = poverty_economized.groupby("Income group").median()

poverty_grouped_medians

# Some more digging on the size_of_economy dataset to look for countries with slight differences in names

size_of_economy

# display(size_of_economy.index.values)

size_of_economy.loc["Moldova"]

Income group      Upper middle income
Region          Europe & Central Asia
Name: Moldova, dtype: object

# Loading the dataset

gini = pd.read_csv("materials_and_methods/Metric_3/indicator_4.csv")

gini

# Filtering to get the year wanted

gini_filtered = gini[gini["Year"] == 2019]

gini_filtered

# Attaching the table with sizes of economy

gini_economized = pd.merge(size_of_economy,
                           gini_filtered,
                           left_index=True,
                           right_on="Entity").drop(["Region", "Code", "Year"], axis=1).set_index("Entity")

gini_economized

# Grouping to see how much of a sample size we have in each group

gini_grouped_and_counted = gini_economized.groupby("Income group").count()

gini_grouped_and_counted

included_names = list(gini_economized.index.values)

excluded_names = ~gini_filtered["Entity"].isin(included_names)

# excluded_names
gini_excluded_values = gini_filtered[excluded_names]

gini_excluded_values

# Loadig the necessary datasets
display(affordability_grouped_by_median, availability_groups_by_median)

# Re-indexing the two tables so that they are good for the total_score function

affordability_cleaned_the_2nd_time = affordability_grouped_by_median.rename(index={"High income" : "high income",
                                                                                   "Upper middle income" : "upper middle income",
                                                                                   "Lower middle income" : "lower middle income",
                                                                                   "Low income" : "low income"})

availability_cleaned_the_2nd_time = availability_groups_by_median.rename(index={"High income" : "high income",
                                                                                "Upper middle income" : "upper middle income",
                                                                                "Lower middle income" : "lower middle income",
                                                                                "Low income" : "low income"})

display(affordability_cleaned_the_2nd_time, availability_cleaned_the_2nd_time)

# Running the totaling function

metric_three_index = total_score_calculator(df=[affordability_cleaned_the_2nd_time, availability_cleaned_the_2nd_time], weights=0.5)


# Sorting results for the highest to the lowest
metric_three_index = metric_three_index.sort_values("index_score", ascending=False)

metric_three_index.sort_values("index_score", ascending=False, inplace=True)

metric_three_index

# Visualizing the information above

sns.barplot(x="index_score",
            y=metric_three_index.index,
            data=metric_three_index,
            palette="mako_r")

<Axes: xlabel='index_score'>

# Loading the dataset

gender_equity = pd.read_csv("materials_and_methods/Metric_4/indicator_1.csv", header=None)

gender_equity

# Renaming columns

gender_equity_renamed = gender_equity.rename({0: "Country", 1: "Global Gender Gap Index"}, axis=1)

gender_equity_renamed

# Resetting the index column and merging the data with the size of economy dataset

gender_equity_cleaned = gender_equity_renamed.set_index("Country")

display(gender_equity_cleaned.head())


gender_equity_economized = pd.merge(size_of_economy,
                                    gender_equity_cleaned,
                                    left_index=True,
                                    right_index=True).drop("Region", axis=1)

gender_equity_economized

# Grouping countries according to the size of economy and checking for sample sizes, mean, and median values.

gender_equity_grouped_and_counted = gender_equity_economized.groupby("Income group").count()

gender_equity_means = gender_equity_economized.groupby("Income group").mean().sort_values("Global Gender Gap Index", ascending=False)

gender_equity_median = gender_equity_economized.groupby("Income group").median().sort_values("Global Gender Gap Index", ascending=False)

display(gender_equity_grouped_and_counted)
display(gender_equity_means)
display(gender_equity_median)

# Visualizing distributions

sns.kdeplot(data=gender_equity_economized,
            x="Global Gender Gap Index",
            hue="Income group")

<Axes: xlabel='Global Gender Gap Index', ylabel='Density'>

# Visualizing outliers (If there are any).

sns.boxplot(data=gender_equity_economized,
            x="Global Gender Gap Index",
            y="Income group")

<Axes: xlabel='Global Gender Gap Index', ylabel='Income group'>

# Removing the outlier: Separating income groups

low_income_equity = gender_equity_economized[gender_equity_economized["Income group"] == "Low income"]

lower_middle_equity = gender_equity_economized[gender_equity_economized["Income group"] == "Lower middle income"]

upper_middle_equity = gender_equity_economized[(gender_equity_economized["Income group"] == "Upper middle income") & 
                                               (gender_equity_economized["Global Gender Gap Index"] > 0.60)]

high_income_equity = gender_equity_economized[gender_equity_economized["Income group"] == "High income"]


# Combining the tables together

gender_equity_wout_outliers = pd.concat([low_income_equity,
                                         lower_middle_equity,
                                         upper_middle_equity,
                                         high_income_equity])

# Visualizing outliers again

sns.boxplot(data=gender_equity_wout_outliers,
            x="Global Gender Gap Index",
            y="Income group")

<Axes: xlabel='Global Gender Gap Index', ylabel='Income group'>

# Visualizing distributions again

sns.kdeplot(data=gender_equity_wout_outliers,
            x="Global Gender Gap Index",
            hue="Income group",
            palette= "seismic")

<Axes: xlabel='Global Gender Gap Index', ylabel='Density'>

# Running ANOVA

# Renaming columns for it
gender_equity_wout_outliers.columns = ["income_group", "gender_gap_index"]


# Creating and fitting the model:
model = ols("gender_gap_index ~ C(income_group)", data=gender_equity_wout_outliers).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

gender_equity_wout_outliers.head()

# Scaling the data
gender_equity_wout_outliers["scaled_values"] = gender_equity_wout_outliers["gender_gap_index"] * 100
 
gender_equity_scaled = gender_equity_wout_outliers

gender_equity_scaled

# Visualizing the distribution of the scaled values

sns.kdeplot(data=gender_equity_scaled,
            x="gender_gap_index",
            hue="income_group",
            palette="seismic")

<Axes: xlabel='gender_gap_index', ylabel='Density'>

# Visualizing the median scaled values

# Grouping the data according to medians
median_gender_equity_scaled = gender_equity_scaled.groupby("income_group").median().sort_values("scaled_values", ascending=False)

display(median_gender_equity_scaled)

# Visualizing the barplot
fig, ax = plt.subplots()
fig.set_size_inches(6, 5)

sns.barplot(data=median_gender_equity_scaled,
            x="scaled_values",
            y=median_gender_equity_scaled.index,
            palette="viridis_r").set_xlabel("Global Gender Gap Index")

Text(0.5, 0, 'Global Gender Gap Index')

# Loading the dataset

child_labor = pd.read_csv("materials_and_methods/Metric_4/indicator_2.csv")

child_labor.head()

# Filtering the dataset according to year 2019, Age-band 5-17, in the agricultural sector, and both sexes.

child_labor_2019 = child_labor[child_labor["time"] == 2019]

child_labor_5years = child_labor_2019[child_labor_2019["classif1.label"] == "Age (Child labour bands): '5-17"]

child_labor_in_agriculture = child_labor_5years[child_labor_5years["classif2.label"] == "Economic activity (Broad sector): Agriculture"]

child_labor_agriculture_both_sexes = child_labor_in_agriculture[child_labor_in_agriculture["sex.label"] == "Sex: Total"][["ref_area.label", 
                                                                                                                          "sex.label", 
                                                                                                                          "classif1.label",
                                                                                                                          "classif2.label",
                                                                                                                          "obs_value"]]

child_labor_agriculture_both_sexes

# Loading the dataframe

community_rights = pd.read_csv("materials_and_methods/Metric_4/indicator_3.csv")

community_rights.head()

# Removing Unwanted columns and rows, and resetting the index

community_rights_cleaned = community_rights.iloc[:, [0, 132]].rename(columns={"Last updated:" : "Country", "Unnamed: 132" : "Overall Score"}).drop([0, 1]).set_index("Country")

community_rights_cleaned.head()

# Joining the sizes of economies

community_rights_economized = pd.merge(size_of_economy,
                                       community_rights_cleaned,
                                       left_index=True,
                                       right_index=True).drop("Region", axis=1)

community_rights_economized.head()

# The "Overall Score" column seems to be a string column. Changing it to float

community_rights_economized["Overall Score"] = community_rights_economized["Overall Score"].astype("float")

community_rights_economized.info()

<class 'pandas.core.frame.DataFrame'>
Index: 64 entries, Argentina to Zimbabwe
Data columns (total 2 columns):
 #   Column         Non-Null Count  Dtype  
---  ------         --------------  -----  
 0   Income group   64 non-null     object 
 1   Overall Score  64 non-null     float64
dtypes: float64(1), object(1)
memory usage: 1.5+ KB

# The sample size seems very small. Checking it.

community_rights_counted = community_rights_economized.groupby("Income group").count().sort_values("Income group", ascending=False)

community_rights_counted

# It seems there isn't enough data to go around. Moving on to another indicator.

# Loading the dataset

animal_welfare = pd.read_csv("materials_and_methods/Metric_4/indicator_4.csv", header=None)

animal_welfare.head()

# Checking the Sample Size

animal_welfare.info()
# Combining the data with Size of Income Dataset

# Renaming columns
animal_welfare.columns = ["Country", "animal_welfare_performance_score"]

# Setting the Index to be the "Country" column
animal_welfare = animal_welfare.set_index("Country")

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 48 entries, 0 to 47
Data columns (total 2 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   0       48 non-null     object
 1   1       48 non-null     int64 
dtypes: int64(1), object(1)
memory usage: 896.0+ bytes

# Merging the dataset with the size_of_ecoonomy dataset
animal_welfare_economized = pd.merge(size_of_economy,
                                     animal_welfare,
                                     left_index=True,
                                     right_index=True).drop("Region", axis=1)

animal_welfare_economized.head()

# Checking the sample size

animal_welfare_economized.groupby("Income group").count()

# Reviewing the necessary datasets
median_gender_equity_scaled


# Since there is only one table, that'll be table used for this metric.

# Loading the dataset

nd_gain = pd.read_csv("materials_and_methods/Metric_5/gain.csv")

nd_gain.head()

# Selecting the relevant year

nd_gain_filtered = nd_gain.loc[:, ["Name", "2019"]]

nd_gain_filtered.head()

# Resetting the index for the dataset

nd_gain_cleaned = nd_gain_filtered.set_index("Name")

nd_gain_cleaned.head()

# Droping missing values

nd_gain_cleaned = nd_gain_cleaned.dropna()

nd_gain_cleaned.head()

# Joining the table with sizes of economy

nd_gain_economized = pd.merge(size_of_economy,
                              nd_gain_cleaned,
                              left_index=True,
                              right_index=True).drop("Region", axis=1)

nd_gain_economized.head()

# Renaming the columns.

nd_gain_economized.columns = ["income_groups", "nd_gain"]

nd_gain_economized.head()

# Exploratory Data Analysis

nd_gain_grouped_mean = nd_gain_economized.groupby("income_groups").mean()

display(nd_gain_grouped_mean)

nd_gain_grouped_median = nd_gain_economized.groupby("income_groups").median()

display(nd_gain_grouped_median)

nd_gain_counted = nd_gain_economized.groupby("income_groups").count()

nd_gain_counted

# Checking the normality

sns.kdeplot(data=nd_gain_economized,
            x="nd_gain",
            hue="income_groups",
            palette="seismic")

<Axes: xlabel='nd_gain', ylabel='Density'>

# It seems like there is an outlier in high_incomes. Checking if that's the case.

sns.boxplot(data=nd_gain_economized,
            x="nd_gain",
            y="income_groups")

<Axes: xlabel='nd_gain', ylabel='income_groups'>

# No outlier. Moving on to ANOVA

# Creating and Fitting The Model
model = ols("nd_gain ~ C(income_groups)", data=nd_gain_economized).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Visualizing the medians.

nd_gain_median_values = nd_gain_economized.groupby("income_groups").median().sort_values("nd_gain", ascending=False)

nd_gain_median_values

# Visualizing the medians
fig, ax = plt.subplots()
fig.set_size_inches(6, 4)

sns.barplot(data=nd_gain_median_values,
            x="nd_gain",
            y=nd_gain_median_values.index,
            palette="rocket").set_xlabel("ND GAIN Values (0=Worst, 100=Best)")

Text(0.5, 0, 'ND GAIN Values (0=Worst, 100=Best)')

# Importing Data for crops
raw_crops = pd.read_csv("materials_and_methods/Metric_5/indicator_2/raw_crops.csv")

raw_crops.head(3)

# Removing columns not wanted
raw_crops_filtered = raw_crops.drop(["Domain Code", 
                                    "Domain", 
                                    "Area Code (M49)", 
                                    "Element", 
                                    "Element Code", 
                                    "Item Code (CPC)",
                                    "Year Code",
                                    "Year",
                                    "Unit",
                                    "Flag",
                                    "Flag Description"], axis=1)


raw_crops_filtered.head()

# Transposing the table so that each country has only one row
raw_crops_refined = raw_crops_filtered.pivot_table(index="Area",
                                                   columns="Item",
                                                   values="Value")

raw_crops_refined.head(10)

# Importing the raw animal products production data

raw_animal = pd.read_csv("materials_and_methods/Metric_5/indicator_2/raw_animal.csv")

raw_animal.head()

# Selecting only the columns that are wanted

raw_animal_filtered = raw_animal.iloc[:, [3, 7, 11]]

raw_animal_filtered.head()

# Transposing the data

raw_animal_refined = raw_animal_filtered.pivot_table(index="Area", columns="Item", values="Value")

raw_animal_refined.head()

# Merging the two tables..

production_quantity = pd.merge(raw_animal_refined,
                               raw_crops_refined,
                               left_index=True,
                               right_index=True)

production_quantity.head()

# Calculating Production Diversity

production_diversity = Shannon_diversity(production_quantity)

production_diversity.head()

# Combining the table above with the size_of_economy table

production_diversity_economized = pd.merge(size_of_economy,
                                           production_diversity,
                                           left_index=True,
                                           right_index=True).drop("Region", axis=1)


production_diversity_economized.head()

# Renaming the columns for ANOVA

production_diversity_economized.columns = ["income_group", "production_diversity_index"]

production_diversity_economized.head()

# Checking the distribution of the data for normality

sns.kdeplot(data=production_diversity_economized,
            x="production_diversity_index",
            hue="income_group",
            palette="seismic")

<Axes: xlabel='production_diversity_index', ylabel='Density'>

# Checking for outliers

sns.boxplot(data=production_diversity_economized,
            x="production_diversity_index",
            y="income_group")

<Axes: xlabel='production_diversity_index', ylabel='income_group'>

# Removing the outliers

production_diversity_high_income = production_diversity_economized[(production_diversity_economized["income_group"] == "High income") \
                                                                   & (production_diversity_economized["production_diversity_index"] > 1.8)]

production_diversity_upper_middle = production_diversity_economized[(production_diversity_economized["income_group"] == "Upper middle income") & \
                                                                    (production_diversity_economized["production_diversity_index"] > 1.1)]

production_diversity_lower_middle = production_diversity_economized[(production_diversity_economized["income_group"] == "Lower middle income") & \
                                                                    (production_diversity_economized["production_diversity_index"] > 1.1)]

production_diversity_low_income = production_diversity_economized[(production_diversity_economized["income_group"] == "Low income") & \
                                                                  (production_diversity_economized["production_diversity_index"] > 1.75)]



# Combining the tables above

clean_production_diversity_scores = pd.concat([production_diversity_high_income,
                                               production_diversity_upper_middle,
                                               production_diversity_lower_middle,
                                               production_diversity_low_income])


clean_production_diversity_scores.head()

# Scaling the data in the clean table

clean_production_diversity_scores["scaled_diversity_indeces"] = clean_production_diversity_scores["production_diversity_index"] * 100/np.log(213)

clean_production_diversity_scores.head()

# Rechecking normality again.

sns.kdeplot(data=clean_production_diversity_scores,
            x="scaled_diversity_indeces",
            hue="income_group",
            palette="seismic")

<Axes: xlabel='scaled_diversity_indeces', ylabel='Density'>

# It seems normality hasn't still been met. Rechecking outliers again

sns.boxplot(data= clean_production_diversity_scores,
            x="scaled_diversity_indeces",
            y="income_group")

<Axes: xlabel='scaled_diversity_indeces', ylabel='income_group'>

# It seems outliers are still there in low income countries. Went back up and removed them from the earlier tables, then I rechecked the boxplot again. The boxplot above is the result of that table.

# Creating the ANOVA model and fitting the data

model = ols("production_diversity_index ~ C(income_group)", data=clean_production_diversity_scores).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Checking the medians

median_production_diversity = clean_production_diversity_scores.groupby("income_group").median().sort_values("production_diversity_index", ascending=False)

median_production_diversity

# Visualizing the data.

fig, ax = plt.subplots()
fig.set_size_inches(6, 4)

sns.barplot(data=median_production_diversity,
            x="scaled_diversity_indeces",
            y=median_production_diversity.index,
            palette="magma").set_xlabel("Production Diversity Scores")

Text(0.5, 0, 'Production Diversity Scores')

# Reviewing the datasets

display(nd_gain_median_values, median_production_diversity)

# Cleaning the datasets such that they have consistent indexes

nd_gain_median_values = nd_gain_median_values.rename(index={"Low income" : "low income", 
                                                            "Upper middle income" : "upper middle income",
                                                            "Lower middle income" : "lower middle income",
                                                            "High income" : "high income"})

median_production_diversity = median_production_diversity.drop("production_diversity_index", axis=1).rename(index={"Low income" : "low income",
                                                                                                                   "Lower middle income" : "lower middle income",
                                                                                                                   "Upper middle income" : "upper middle income",
                                                                                                                   "High income" : "high income"})

display(nd_gain_median_values, median_production_diversity)

# Calculating the total metric score

total_score_metric_5 = total_score_calculator(df=[nd_gain_median_values, median_production_diversity], weights= 0.5)

total_score_metric_5.sort_values("index_score", ascending=False, inplace=True)

total_score_metric_5

# Visualizing the information above

sns.barplot(x="index_score",
            y=total_score_metric_5.index,
            data=total_score_metric_5,
            palette="viridis")

<Axes: xlabel='index_score'>

# Loading the dataset

food_safety = pd.read_csv("materials_and_methods/Metric_6/gfsi_food_safety_scores.csv", header=None)

food_safety.head()

# Renaming columns and resetting the index

food_safety.columns = ["country", "gfsi_safety_score"]

food_safety = food_safety.set_index("country")

food_safety.head()

# Joining the table with the size_of_economy table..

food_safety_economized = pd.merge(size_of_economy,
                                  food_safety,
                                  left_index=True,
                                  right_index=True).drop("Region", axis=1)

food_safety_economized.head()

# Checking the sample size

food_safety_economized.groupby("Income group").count()

# Renaming columns for future analyses

food_safety_economized.columns = ["income_group", "gfsi_safety_score"]

food_safety_economized.head()

# Checking for normality

sns.kdeplot(data=food_safety_economized,
            x="gfsi_safety_score",
            hue="income_group",
            palette="seismic")

<Axes: xlabel='gfsi_safety_score', ylabel='Density'>

# Checking for outliers

sns.boxplot(data=food_safety_economized,
            x="gfsi_safety_score",
            y="income_group")

<Axes: xlabel='gfsi_safety_score', ylabel='income_group'>

# Running ANOVA

# Creating and fitting the model

model = ols("gfsi_safety_score ~ C(income_group)", data=food_safety_economized).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Evaluating the medians

median_food_safety = food_safety_economized.groupby("income_group").median().sort_values("gfsi_safety_score", ascending=False)

median_food_safety

# Visualizing the medians

fig, ax = plt.subplots()
fig.set_size_inches(6, 5)

sns.barplot(data=median_food_safety,
            x="gfsi_safety_score",
            y=median_food_safety.index,
            palette="icefire")

<Axes: xlabel='gfsi_safety_score', ylabel='income_group'>

# Loading the dataset

food_waste = pd.read_csv("materials_and_methods/Metric_7.csv")

food_waste.head()

# Removing columns not needed and resetting the index..

food_waste_cleaned = food_waste.drop(["Code", "Year"], axis=1).set_index("Entity")

food_waste_cleaned.head()

# Checking the sample size

food_waste_cleaned.info()

<class 'pandas.core.frame.DataFrame'>
Index: 229 entries, Afghanistan to Zimbabwe
Data columns (total 3 columns):
 #   Column                                                                          Non-Null Count  Dtype  
---  ------                                                                          --------------  -----  
 0   12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Retail                   228 non-null    float64
 1   12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Out-of-home consumption  229 non-null    float64
 2   12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Households               228 non-null    float64
dtypes: float64(3)
memory usage: 7.2+ KB

# Adding the data from all three columns. This will constitute total per capita food waste in a country.

food_waste_cleaned["food_waste_total"] = food_waste_cleaned["12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Households"] + \
                                         food_waste_cleaned["12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Out-of-home consumption"] + \
                                         food_waste_cleaned["12.3.1 - Food waste per capita (KG) - AG_FOOD_WST_PC - Retail"]

food_waste_cleaned.head()

# Combining the table with sizes_of_economy

food_waste_economized = pd.merge(size_of_economy,
                                 food_waste_cleaned,
                                 left_index=True,
                                 right_index=True).drop("Region", axis=1)

food_waste_economized.head()

# Renaming columns for other steps of the analysis

food_waste_economized.columns = ["income_group", "retail_food_waste", "out_of_home_food_waste", "household_food_waste", "food_waste_total"]

food_waste_economized.head()

# Checking the samples size again

food_waste_economized.groupby("income_group").count()

# Checking the distributions

fig, ax = plt.subplots(2,2)

sns.kdeplot(data=food_waste_economized,
            x="retail_food_waste",
            hue="income_group",
            ax=ax[0][0], legend=False, log_scale = True)

sns.kdeplot(data=food_waste_economized,
            x="out_of_home_food_waste",
            hue="income_group",
            ax=ax[0][1], legend=False)

sns.kdeplot(data=food_waste_economized,
            x="household_food_waste",
            hue="income_group",
            ax=ax[1][0], legend=False)

sns.kdeplot(data=food_waste_economized,
            x="food_waste_total",
            hue="income_group",
            ax=ax[1][1])

plt.subplots_adjust(hspace=0.7, wspace= 0.7)

sns.move_legend(ax[1][1], "lower left", bbox_to_anchor=(1, 0), frameon=True)

# It is difficult to infer from 2 of the 3 main sources of waste. Looking at boxplots

fig, ax = plt.subplots(2,2)

sns.boxplot(data=food_waste_economized,
            x="retail_food_waste",
            y="income_group",
            ax=ax[0][0])

sns.boxplot(data=food_waste_economized,
            x="out_of_home_food_waste",
            y="income_group",
            ax=ax[0][1])

sns.boxplot(data=food_waste_economized,
            x="household_food_waste",
            y="income_group",
            ax=ax[1][0])

sns.boxplot(data=food_waste_economized,
            x="food_waste_total",
            y="income_group",
            ax=ax[1][1])

plt.subplots_adjust(hspace=0.7, wspace= 0.7)

# From the two visualizations above, it seems it is better to use the total food waste per capita.

# Visualiziing total waste per capita separately

sns.boxplot(data=food_waste_economized,
            x="food_waste_total",
            y="income_group")

<Axes: xlabel='food_waste_total', ylabel='income_group'>

food_waste_economized.groupby("income_group").median()

# Removing the outliers

food_waste_high_income = food_waste_economized[(food_waste_economized["income_group"] == "High income") & \
                                               (food_waste_economized["food_waste_total"] > 97) & \
                                               (food_waste_economized["food_waste_total"] < 145)]

food_waste_low_income = food_waste_economized[(food_waste_economized["income_group"] == "Low income") & \
                                              (food_waste_economized["food_waste_total"] > 144) & \
                                              (food_waste_economized["food_waste_total"] < 200)]

food_waste_lower_middle = food_waste_economized[(food_waste_economized["income_group"] == "Lower middle income") & \
                                                (food_waste_economized["food_waste_total"] > 87) & \
                                                (food_waste_economized["food_waste_total"] < 225)]

food_waste_upper_middle = food_waste_economized[(food_waste_economized["income_group"] == "Upper middle income") & \
                                                (food_waste_economized["food_waste_total"] > 100) & \
                                                (food_waste_economized["food_waste_total"] < 150)]


# Combining the frames

food_waste_wout_outliers = pd.concat([food_waste_low_income,
                                      food_waste_lower_middle,
                                      food_waste_upper_middle,
                                      food_waste_high_income])


food_waste_wout_outliers.head()

# Checking the samples size

food_waste_wout_outliers.groupby("income_group").count()

# Visualizing the data again to see if there remains outliers

sns.boxplot(data=food_waste_wout_outliers,
            x="food_waste_total",
            y="income_group")

<Axes: xlabel='food_waste_total', ylabel='income_group'>

# We're clear on outliers. Moving on with ANOVA

model = ols("food_waste_total ~ C(income_group)", data=food_waste_wout_outliers).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

food_waste_wout_outliers

# Scaling the values to a 0-100 performance scale

scaled_food_waste = scaler(food_waste_wout_outliers[["income_group", "food_waste_total"]], column="food_waste_total")

scaled_food_waste.head()

/tmp/ipykernel_351/3034917137.py:15: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df["Scaled Values"] = scaled_values

# Checking the medians

median_food_waste = scaled_food_waste.groupby("income_group").median().sort_values("Scaled Values", ascending=False)

median_food_waste

# Putting food wastage as percentages

median_food_waste["Percentage"] = (median_food_waste["food_waste_total"] / median_food_waste["food_waste_total"].sum()) * 100

median_food_waste

# Visualizing the information above

fig, ax = plt.subplots()
fig.set_size_inches(6, 5)

sns.barplot(data=median_food_waste,
            x="Scaled Values",
            y=median_food_waste.index,
            palette="mako_r").set_xlabel("Performance on Waste and Loss Reduction (0=Worst, 100=Best)")

Text(0.5, 0, 'Performance on Waste and Loss Reduction (0=Worst, 100=Best)')

# Loading the necessary datasets 

display(index_scores_metric_1,
        metric_2_scores,
        metric_three_index,
        median_gender_equity_scaled,
        total_score_metric_5,
        median_food_safety,
        median_food_waste)

# Selecting columns needed from each dataset and renaming them accordingly

# Metric 1
metric_1_scores = index_scores_metric_1.rename(columns={"index_score" : "metric_1"})
display(metric_1_scores)


# Metric_2
metric_2_scores.rename(columns={"index_score" : "metric_2"}, inplace=True)
display(metric_2_scores)


# Metric_3
metric_3_scores = metric_three_index.rename(columns={"index_score" : "metric_3"})
display(metric_3_scores)


# Metric_4
metric_4_scores = median_gender_equity_scaled[["scaled_values"]].rename(columns={"scaled_values" : "metric_4"})
display(metric_4_scores)


# Metric_5
metric_5_scores = total_score_metric_5.rename(columns={"index_score" : "metric_5"})
display(metric_5_scores)


# Metric 6
metric_6_scores = median_food_safety.rename(columns={"gfsi_safety_score" : "metric_6"})

# Metric 7
metric_7_scores = median_food_waste[["Percentage"]].rename(columns={"Percentage" : "metric_7"})

# Reforming the datasets for metric 7: Values weren't scaled according to performance. Taking the ones that were after going back and scaling the respective datasets
metric_7_scores = median_food_waste[["Scaled Values"]].rename(columns={"Scaled Values" : "metric_7"})


display(metric_7_scores)

# Concatenating all the tables

metric_scores_all = pd.concat([metric_1_scores,
                               metric_2_scores,
                               metric_3_scores,
                               metric_4_scores,
                               metric_5_scores,
                               metric_6_scores,
                               metric_7_scores], axis=1)

metric_scores_all

# Metric 4, 6, and 7 need a re-indexing.

container = [metric_4_scores, metric_6_scores, metric_7_scores]

for frame in container :
    frame.rename(index={"High income" : "high income",
                        "Upper middle income" : "upper middle income",
                        "Lower middle income" : "lower middle income",
                        "Low income" : "low income"}, inplace=True)
    

display(metric_4_scores, metric_6_scores, metric_7_scores)

# Re-running the concatenating code

metric_scores_all = pd.concat([metric_1_scores,
                               metric_2_scores,
                               metric_3_scores,
                               metric_4_scores,
                               metric_5_scores,
                               metric_6_scores,
                               metric_7_scores], axis=1)

metric_scores_all

# Exporting the table
metric_scores_all.T.to_csv("metric_score_all.csv")

# Plotting the information above

# Transposing the frame so that income groups become columns
metric_scores_transposed = metric_scores_all.T

metric_scores_transposed

df = metric_scores_transposed


# Plotting it on a bar graph
fig, ax = plt.subplots(2, 2, sharey=True)
fig.set_size_inches(12, 8)

sns.barplot(x="low income",
            y=df.index,
            data=df,
            ax=ax[0][0],
            palette="viridis_r").set(xlabel="", title="Low Income")

sns.barplot(x="lower middle income",
            y=df.index,
            data=df,
            ax=ax[0][1],
            palette="viridis_r").set(title="Lower Middle Income", xlabel="")

sns.barplot(x="upper middle income",
            y=df.index,
            data=df,
            ax=ax[1][0],
            palette="viridis_r").set(title="Upper Middle Income", xlabel="")

sns.barplot(x="high income",
            y=df.index,
            data=df,
            ax=ax[1][1],
            palette="viridis").set(title="High Income", xlabel="")

[Text(0.5, 1.0, 'High Income'), Text(0.5, 0, '')]

# Melting the frame to be able to run MANOVA in it smoothly

# Resetting the index to make it part of columns in the dataframe
df.reset_index(inplace=True)

df = df.melt(id_vars="index")

df

# Running ANOVA

# Creating the model

model = ols("value ~ C(variable)", data=df).fit()

anova = sm.stats.anova_lm(model, typ=2)

anova

# Preparing a polar chart for the data. Writing a function that does that.

def polar_charts(df=list, label_col = str, data_col = str, label_is_index = bool, plot_ax=int) :
    """Creates Polar Charts"""

    
    for frame in df :   
        # Separating the labels
        if label_is_index == False :

            labels = df.groupby(label_col).count().index.values

        else :

            a = df.reset_index()

            labels = a["index"].values


        # Separating values
        statistics = df[data_col].values

        statistics


        # Setting the angles of the polar axes
        angles = np.linspace(0, 2*np.pi, len(labels), endpoint=False)


        # Closing the plot
        statistics = np.concatenate((statistics, [statistics[0]]))

        angles = np.concatenate((angles, [angles[0]]))


    # Plotting the graph
    fig = plt.figure()

    ax = fig.add_subplot(111, polar=True)

    ax.plot(angles, statistics, 'o-', linewidth=2)

    ax.set_thetagrids((angles * 180/np.pi)[:7], labels)

    ax.set_title(data_col)
    ax.grid(True)

# Plotting
# fig, ax = plt.subplots(2, 2, subplot_kw={"projection" : "polar"})

polar_charts(df=metric_scores_transposed,
             data_col="low income",
             label_is_index=True)


polar_charts(df=metric_scores_transposed,
             data_col="lower middle income",
             label_is_index=True)

polar_charts(df=metric_scores_transposed,
             data_col="upper middle income",
             label_is_index=True)

polar_charts(df=metric_scores_transposed,
             data_col="high income",
             label_is_index=True)

plt.show()

# Melting the frame in order to have only 2 vars

# Resetting the index of the data in order to use at as "id_vars"
metric_scores_transposed = metric_scores_transposed.reset_index()

metric_scores_transposed

# Melting the frame
metric_scores_melted = pd.melt(frame=metric_scores_transposed,
                               id_vars="index",
                               var_name="income_groups")

metric_scores_melted

# Plottting the information above on a barplot

g = sns.FacetGrid(data=metric_scores_melted, col="income_groups", sharex=True, sharey=True, palette="Blues")

g.map(sns.barplot, x="value", y="income_groups")

/home/mukajanga/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/axisgrid.py:712: UserWarning: Using the barplot function without specifying `order` is likely to produce an incorrect plot.
  warnings.warn(warning)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
/home/mukajanga/Desktop/Projects/thesis/Materials_and_methods.ipynb Cell 389 line 5
      <a href='vscode-notebook-cell:/home/mukajanga/Desktop/Projects/thesis/Materials_and_methods.ipynb#Z1665sZmlsZQ%3D%3D?line=0'>1</a> # Plottting the information above on a barplot
      <a href='vscode-notebook-cell:/home/mukajanga/Desktop/Projects/thesis/Materials_and_methods.ipynb#Z1665sZmlsZQ%3D%3D?line=2'>3</a> g = sns.FacetGrid(data=metric_scores_melted, row="income_groups", sharex=True, sharey=True, palette="Blues")
----> <a href='vscode-notebook-cell:/home/mukajanga/Desktop/Projects/thesis/Materials_and_methods.ipynb#Z1665sZmlsZQ%3D%3D?line=4'>5</a> g.map(sns.barplot, x="value", y="income_groups")

File ~/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/axisgrid.py:752, in FacetGrid.map(self, func, *args, **kwargs)
    749         plot_args = [v.values for v in plot_args]
    751     # Draw the plot
--> 752     self._facet_plot(func, ax, plot_args, kwargs)
    754 # Finalize the annotations and layout
    755 self._finalize_grid(args[:2])

File ~/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/axisgrid.py:848, in FacetGrid._facet_plot(self, func, ax, plot_args, plot_kwargs)
    846     plot_args = []
    847     plot_kwargs["ax"] = ax
--> 848 func(*plot_args, **plot_kwargs)
    850 # Sort out the supporting information
    851 self._update_legend_data(ax)

File ~/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/categorical.py:2755, in barplot(data, x, y, hue, order, hue_order, estimator, errorbar, n_boot, units, seed, orient, color, palette, saturation, width, errcolor, errwidth, capsize, dodge, ci, ax, **kwargs)
   2752 if estimator is len:
   2753     estimator = "size"
-> 2755 plotter = _BarPlotter(x, y, hue, data, order, hue_order,
   2756                       estimator, errorbar, n_boot, units, seed,
   2757                       orient, color, palette, saturation,
   2758                       width, errcolor, errwidth, capsize, dodge)
   2760 if ax is None:
   2761     ax = plt.gca()

File ~/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/categorical.py:1530, in _BarPlotter.__init__(self, x, y, hue, data, order, hue_order, estimator, errorbar, n_boot, units, seed, orient, color, palette, saturation, width, errcolor, errwidth, capsize, dodge)
   1525 def __init__(self, x, y, hue, data, order, hue_order,
   1526              estimator, errorbar, n_boot, units, seed,
   1527              orient, color, palette, saturation, width,
   1528              errcolor, errwidth, capsize, dodge):
   1529     """Initialize the plotter."""
-> 1530     self.establish_variables(x, y, hue, data, orient,
   1531                              order, hue_order, units)
   1532     self.establish_colors(color, palette, saturation)
   1533     self.estimate_statistic(estimator, errorbar, n_boot, seed)

File ~/Desktop/Projects/thesis/.venv/lib/python3.10/site-packages/seaborn/categorical.py:541, in _CategoricalPlotter.establish_variables(self, x, y, hue, data, orient, order, hue_order, units)
    539     if isinstance(var, str):
    540         err = f"Could not interpret input '{var}'"
--> 541         raise ValueError(err)
    543 # Figure out the plotting orientation
    544 orient = infer_orient(
    545     x, y, orient, require_numeric=self.require_numeric
    546 )

ValueError: Could not interpret input 'value'

# CODE APPENDIX


# 1. Visualizing distributions of the data

# fig, ((ax1, ax2), 
#       (ax3, ax4), 
#       (ax5, ax6), 
#       (ax7, ax8), 
#       (ax9, ax10), 
#       (ax11, ax12), 
#       (ax13, ax14)) = plt.subplots(7, 2, sharey=True, sharex=False, figsize=(7, 13))

# def distributions(df, x, y, ax) :
    
#     """Plots Boxplots for income groups"""
    
#     g = sns.boxplot(data=df,
#                     ax= ax,
#                     x=x,
#                     palette='tab10',
#                     y=y).set(xlabel='',
#                              ylabel='',
#                              title=x)
    
#     ax.set_title(x, fontsize=8)
    
#     ax.tick_params(axis='both', which='major', labelsize=7)
    
#     return g

# plt.suptitle('Distribution of Values among Different Food Groups', y= 0.95, fontsize=10)
# plt.subplots_adjust(hspace= 0.7)
# #plt.savefig('Distribution_of_Daily_Kcal_Intakes.png')

# sns.move_legend(ax, "lower left", bbox_to_anchor=(1, 0), frameon=True)


# Refer to the last 6 lines of this code block for finer customizations of Seaborn plots.

	Income group	Cereals	Roots & Tubers	Seeds, Nuts, and Oils	Starchs & Sugars	Dairy & Egg Products	Finfish / Shellfish Products	Poultry	Pork	Beef Products	Spices & Herbs	Legumes & Products	Vegetables	Fruits & Plantains	Infant food
Country
Afghanistan	Low income	7.335764	3.977811	5.344724	5.004617	4.787492	0.530628	1.791759	-inf	3.914021	1.098612	2.844909	3.529297	4.079231	0.000000
Angola	Lower middle income	6.634765	6.597555	5.772998	5.069533	2.639057	3.182212	3.496508	4.343805	3.666122	-inf	4.345103	2.708050	4.635699	0.000000
Albania	Upper middle income	6.971856	4.492001	5.804834	5.318610	6.573680	2.708050	4.127134	4.077537	5.100476	-2.302585	3.912023	5.337538	5.666773	0.000000
United Arab Emirates	High income	6.984161	3.666122	6.698638	5.847017	5.389072	3.737670	4.709530	-2.302585	4.745801	2.302585	5.075174	4.007333	4.691348	1.609438
Argentina	Upper middle income	6.955974	4.434382	6.002404	6.080162	5.693732	2.397895	5.267858	4.718499	6.011512	3.295837	4.007333	3.988984	4.394449	-2.302585

	Income group	Cereals	Roots & Tubers	Seeds, Nuts, and Oils	Starchs & Sugars	Dairy & Egg Products	Finfish / Shellfish Products	Poultry	Beef Products	Legumes & Products	Vegetables	Fruits & Plantains
Country
Afghanistan	Low income	7.335764	3.977811	5.344724	5.004617	4.787492	0.530628	1.791759	3.914021	2.844909	3.529297	4.079231
Angola	Lower middle income	6.634765	6.597555	5.772998	5.069533	2.639057	3.182212	3.496508	3.666122	4.345103	2.708050	4.635699

	income_group	cereals	roots_and_tubers	seeds_nuts_and_oils	starches_and_sugars	dairy_and_egg_products	finfish_and_shellfish_products	poultry	beef_products	legumes_and_products	vegetables	fruits_and_plantains
Country
Afghanistan	Low income	7.335764	3.977811	5.344724	5.004617	4.787492	0.530628	1.791759	3.914021	2.844909	3.529297	4.079231
Angola	Lower middle income	6.634765	6.597555	5.772998	5.069533	2.639057	3.182212	3.496508	3.666122	4.345103	2.708050	4.635699
Albania	Upper middle income	6.971856	4.492001	5.804834	5.318610	6.573680	2.708050	4.127134	5.100476	3.912023	5.337538	5.666773
United Arab Emirates	High income	6.984161	3.666122	6.698638	5.847017	5.389072	3.737670	4.709530	4.745801	5.075174	4.007333	4.691348
Argentina	Upper middle income	6.955974	4.434382	6.002404	6.080162	5.693732	2.397895	5.267858	6.011512	4.007333	3.988984	4.394449

Income group	High income	Low income	Lower middle income	Upper middle income
Cereals	988.30	1266.1	1281.70	1099.2
Roots & Tubers	86.60	307.1	116.55	89.3
Seeds, Nuts, and Oils	476.55	285.4	301.75	377.4
Starchs & Sugars	357.10	99.1	211.05	329.1
Dairy & Egg Products	421.00	47.0	100.10	225.0
Finfish / Shellfish Products	45.00	9.0	20.00	18.0
Poultry	109.50	9.0	23.50	88.0
Pork	152.00	9.0	13.50	59.0
Beef Products	172.60	41.1	71.15	107.1
Spices & Herbs	6.00	1.0	2.55	3.0
Legumes & Products	32.00	85.0	71.05	51.0
Vegetables	76.00	31.0	43.00	65.0
Fruits & Plantains	127.50	80.0	91.00	116.0
Infant food	3.00	0.0	1.00	2.0

Item	Apples and products	Aquatic Animals, Others	Aquatic Plants	Bananas	Barley and products	Beans	Bovine Meat	Butter, Ghee	Cassava and products	Cephalopods	...	Sugar non-centrifugal	Sunflower seed	Sunflowerseed Oil	Sweet potatoes	Sweeteners, Other	Tea (including mate)	Tomatoes and products	Vegetables, other	Wheat and products	Yams
Country
Afghanistan	2.95	NaN	NaN	3.11	0.07	0	2.73	0.97	0.01	NaN	...	NaN	NaN	1.27	0	0.54	2	0.89	55.39	158.95	NaN
Albania	32.66	0	0	8.26	0.2	5.03	13.2	1.52	0	0.72	...	NaN	NaN	4.72	0.01	24.22	0.15	77.88	217.39	124.68	NaN
Algeria	12.38	0	0	4.32	15.01	1.54	4.85	0.4	0	0.03	...	NaN	NaN	1.26	0	2.81	0.36	34.52	137.39	181.92	NaN
Angola	0.38	0	0	37.32	0	7.24	4.17	0.04	226.1	0	...	NaN	NaN	0.27	39.53	9.23	0.03	2.12	20.49	27.17	NaN
Antigua and Barbuda	5.47	NaN	0	17.87	0	1.03	6.74	1.26	0.78	0.25	...	NaN	0.04	0.09	2.33	28.34	0.73	5.82	44.71	68.7	1.35

An Evaluation of National Food System According to the Sustainable Nutritional Security Criteria: The Analysis.¶

Metric 1: Food Nutrient Adequacy¶

Indicator 1: Non-Staple Food Energy¶

Indicator 2: Shannon Diversity¶

Indicator 3: Modified Functional Attibutite Diversity¶

Notes for the food condenser¶

Indicator 4: Nutrient Balance Score¶

Total Score: Metric 1.¶

Metric 2: Ecosystem Stability¶

1st Indicator: Ecosystem Status¶

2nd Indicator: Per Capita GHG Emissions¶

Indicator 3: Per Capita Net Freshwater Withdrawal¶

Indicator 4: Per Capita Non-Renewable Energy Use¶

Indicator 5: Per Capita Land Use¶

Total Metric Score: Metric 2¶

Metric 3: Food Affordability and Availability¶

Indicator 1: Food Affordability¶

Indicator 2: Food Availability¶

Indicator 3: Poverty Index¶

Indicator 4: Income Inequality¶

Total Metric Score: Metric 3¶

Metric 4: Sociocultural Wellbeing¶

Indicator 1: Gender Equity¶

Indicator 2: Instances of Child Labor¶

Indicator 3: Respect For Community Rights¶

Indicator 4: Animal Welfare¶

Total Metric Score¶

Metric 5: Resilience¶

Indicator 1: ND-GAIN¶

Indicator 2: Food Production Diversity¶

Total Metric Score¶

Metric 6: Food Safety¶

Metric 7: Food Waste¶

The Seven Metrics plotted¶

			Sources
The Metric	Indicators	What They Measure
Food Nutrient Adequacy	Non-Staple Food Energy	Nutrients From Non-Staple Food	FAOs Food Balance Sheets
	Shannon Diversity	Nutrient Diversity in The Food System	FAOs Food Balance Sheets
	Modified Functional Attribute Diversity	Nutrient Diversity in The Food System	FAOs Food Balance Sheets
	Nutrient Density Score	Nutrient Diversity in The Food System	FAOs Food Balance Sheets
	Population Share With Adequate Nutrients	Proportion of Population With Adequate Nutrients	FAOSTATS
Ecosystem Stability	Ecosystem Status	Ecosystem Status	Yale Center for Environmental Law and Policy
	GHG Emissions	Eco-Efficiency	United Nations Framework Convention on Climate Change
	Net FreshWater Withdrawals	Eco-Efficiency	Data Collections, NASA
	Energy Use	Eco-Efficiency	Data Collections, NASA
	Land Use	Eco-Efficiency	Data Collections, NASA
Food Affordability & Availability	Income Equality	Food Availability & Affordability	Global Food Security Index (GFSI)
	Poverty Index	Food Availability & Affordability	Global Food Security Index (GFSI)
	GFSI Food Availability Score	Food Availability & Affordability	United Nations, 2021
	Food Affordability	Food Availability & Affordability	United Nations, 2021
Socialcultural Wellbeing	Animal Health & Welfare	Gender Equality	Global Gender Gap Report 2020
	Community Rights	Extent of Child Labor	ILO, 2020
	Child Labor	Respect for Community Rights	Environmental Democracy Index
	Gender Equity	Animal Health & Welfare	Not Measured (Insufficient Data)
Resilience	Food Production Diversity	Nation's Vulnerability to Climate Change	Notre Dame Global Adaptation Initiative
Resilience	ND-GAIN Country Index	Shares of Agricultural Food Production in The Country	FAOSTAT
Food Safety	GFSI Safety Score	Food Borne Disease Burden	World Health Organisation (WHO)
Food Safety	Foodborne Disease Burden	GFSI Food Safety	Global Food Security Index (GFSI)
Waste & Loss Reduction	Pre & Post-Consumer Food Loss	FAO	FAO

	Income group	Region
Country
Aruba	High income	Latin America & Caribbean
Afghanistan	Low income	South Asia
Angola	Lower middle income	Sub-Saharan Africa
Albania	Upper middle income	Europe & Central Asia
Andorra	High income	Europe & Central Asia

	Country	Food	Value
0	Afghanistan	Wheat and products	1362
1	Afghanistan	Rice and products	140
2	Afghanistan	Barley and products	1
3	Afghanistan	Maize and products	30
4	Afghanistan	Oats	0
5	Afghanistan	Millet and products	1
6	Afghanistan	Cereals, Other	0
7	Afghanistan	Cassava and products	0
8	Afghanistan	Potatoes and products	53
9	Afghanistan	Roots, Other	0

Food	Apples and products	Aquatic Animals, Others	Aquatic Plants	Bananas	Barley and products	Beans	Beer	Beverages, Alcoholic	Beverages, Fermented	Bovine Meat	...	Sunflower seed	Sunflowerseed Oil	Sweet potatoes	Sweeteners, Other	Tea (including mate)	Tomatoes and products	Vegetables, other	Wheat and products	Wine	Yams
Country
Afghanistan	4.0	NaN	NaN	5.0	1.0	NaN	0.0	0.0	0.0	16.0	...	NaN	31.0	NaN	1.0	2.0	0.0	30.0	1362.0	0.0	NaN
Albania	44.0	0.0	0.0	14.0	1.0	46.0	44.0	6.0	0.0	59.0	...	NaN	114.0	0.0	33.0	0.0	39.0	137.0	969.0	4.0	NaN
Algeria	16.0	0.0	0.0	7.0	107.0	14.0	5.0	1.0	0.0	24.0	...	NaN	30.0	0.0	10.0	0.0	20.0	100.0	1398.0	0.0	NaN
Angola	0.0	0.0	0.0	72.0	0.0	67.0	44.0	9.0	23.0	21.0	...	NaN	6.0	104.0	10.0	0.0	1.0	13.0	193.0	2.0	NaN
Antigua and Barbuda	7.0	NaN	0.0	29.0	0.0	10.0	42.0	65.0	1.0	36.0	...	0.0	2.0	6.0	31.0	1.0	5.0	40.0	585.0	19.0	3.0

	Cereals	Seeds, Nuts, and Oils	Dairy & Egg Products	Starchs & Sugars	Beef Products	Pork	Fruits & Plantains	Poultry	Roots & Tubers	Vegetables	Finfish / Shellfish Products	Legumes & Products	Spices & Herbs	Infant food	Total
Income group
High income	988.3	476.55	421.0	357.1	172.6	152.0	127.5	109.5	86.6	76.0	45.0	32.0	6.0	3.0	3053.15
Percent	32.4	15.60	13.8	11.7	5.7	5.0	4.2	3.6	2.8	2.5	1.5	1.0	0.2	0.1	100.00

	Cereals	Seeds, Nuts, and Oils	Starchs & Sugars	Roots & Tubers	Dairy & Egg Products	Fruits & Plantains	Beef Products	Legumes & Products	Vegetables	Poultry	Finfish / Shellfish Products	Pork	Spices & Herbs	Infant food	Total
Income group
Lower middle income	1281.7	301.75	211.05	116.55	100.1	91.0	71.15	71.05	43.0	23.5	20.0	13.5	2.55	1.0	2347.9
Percent	54.6	12.90	9.00	5.00	4.3	3.9	3.00	3.00	1.8	1.0	0.9	0.6	0.10	0.0	100.0

				Percent of Median Calorie Intake
Income group	Staple Foods	Percent of Median Daily Calorie Intake	Non-Staple Foods
Low Income	Cereals	55.8	Starchs & Sugars	4.4
			Legumes & Products	3.7
			Fruits & Plantains	3.5
			Dairy & Egg Products	2.1
	Roots & Tubers	13.5	Beef Products	1.8
			Vegetables	1.4
			Finfish / Shellfish Products	0.4
			Poultry	0.4
	Seeds, Nuts, and Oils	12.6	Pork	0.4
			Spices & Herbs	0.0
			Infant Foods	0.0
Lower Middle Income	Cereals	54.6	Starchs & Sugars	9.0
			Roots & Tubers	5.0
			Dairy & Egg Products	4.3
			Fruits & Plantains	3.9
			Beef Products	3.0
			Legumes & Products	3.0
	Seeds, Nuts, and Oils	12.8	Vegetables	1.8
			Poultry	1.0
			Finfish / Shellfish Products	0.9
			Pork	0.6
			Spices & Herbs	0.1
			Infant Food	0.0
Upper Middle Income	Cereals	41.8	Dairy & Egg Products	8.6
			Fruits & Plantains	4.4
			Beef Products	4.1
			Roots & Tubers	3.4
			Poultry	3.3
	Seeds, Nuts, and Oils	14.3	Vegetables	2.5
			Pork	2.2
			Legumes & Products	1.9
	Starchs & Sugars	12.5	Finfish / Shellfish Products	0.7
			Spices & Herbs	0.1
			Infant food	0.1
High Income	Cereals	32.4	Starchs & Sugars	11.7
			Beef Products	5.7
			Pork	5.0
			Fruits & Plantains	4.2
			Poultry	3.6
	Seeds, Nuts, and Oils	15.6	Roots & Tubers	2.8
			Vegetables	2.5
			Finfish / Shellfish Products	1.5
	Dairy & Egg Products	13.8	Legumes & Products	1.0
			Spices & Herbs	0.2
			Infant Food	0.1

	Percent of kcal from non-staple foods
High income	38.3
Lower middle income	32.6
Upper middle income	31.3
Low income	18.1

	Apples and products	Aquatic Animals, Others	Aquatic Plants	Bananas	Barley and products	Beans	Bovine Meat	Butter, Ghee	Cassava and products	Cephalopods	...	Sugar non-centrifugal	Sunflower seed	Sunflowerseed Oil	Sweet potatoes	Sweeteners, Other	Tea (including mate)	Tomatoes and products	Vegetables, other	Wheat and products	Yams
Income group
High income	0.0	6.521739	2.173913	0.000000	4.347826	4.347826	0.0	0.0	50.000000	2.173913	...	95.652174	47.826087	0.000000	13.043478	0.0	0.0	0.0	0.0	0.0	32.608696
Low income	0.0	33.333333	14.285714	4.761905	0.000000	0.000000	0.0	0.0	0.000000	9.523810	...	90.476190	52.380952	0.000000	0.000000	0.0	0.0	0.0	0.0	0.0	33.333333
Lower middle income	0.0	9.090909	4.545455	2.272727	0.000000	2.272727	0.0	0.0	6.818182	0.000000	...	68.181818	40.909091	0.000000	9.090909	0.0	0.0	0.0	0.0	0.0	50.000000
Upper middle income	0.0	4.444444	0.000000	0.000000	4.444444	6.666667	0.0	0.0	15.555556	0.000000	...	80.000000	35.555556	2.222222	2.222222	0.0	0.0	0.0	0.0	0.0	44.444444

	Income group	Region	Cereals	Roots & Tubers	Vegetables	Fruits & Plantains	Seeds, Nuts, and Oils	Starch and Sugars	Infant Food	Dairy and Egg Products	Finfish / Shellfish Products	Beef Products	Poultry	Legume and Legume Products	Spices & Herbs
Country
Spain	High income	Europe & Central Asia	113.1	60.3	120.2	93.7	48.5	32.5	0.4	182.0	40.8	21.8	33.3	5.8	0.4
Chile	High income	Latin America & Caribbean	153.3	57.9	71.9	59.9	10.8	41.2	0.0	94.1	14.0	26.8	38.7	3.9	1.5
Iceland	High income	Europe & Central Asia	84.4	35.6	77.2	89.1	28.0	80.6	0.3	232.1	91.2	42.8	31.4	1.1	1.6
Sweden	High income	Europe & Central Asia	115.0	53.9	85.1	60.9	21.8	46.5	0.3	234.7	32.3	32.8	16.3	2.5	1.1
Slovenia	High income	Europe & Central Asia	140.1	38.1	99.5	104.7	16.6	44.7	0.0	192.0	13.2	20.9	29.1	1.4	0.3

	KNN_Imputed	MICE_Imputed
Adj. Rsquared	0.882185	0.890507
const	116.161064	115.261280

	Production Diversity Indeces
Country
Spain	2.138885
Chile	2.105233
Iceland	2.115612
Sweden	2.019177
Slovenia	1.987958
...	...
Mexico	2.034659
Ecuador	1.950009
Dominican Republic	1.849328
Cuba	2.050092
Lebanon	2.085413

	diversity_indeces
income_group
High income	2.071434
Low income	1.808516
Lower middle income	1.848279
Upper middle income	1.986051

	diversity_indeces
income_group
High income	2.088878
Low income	1.775004
Lower middle income	1.854956
Upper middle income	2.010195

	sum_sq	df	F	PR(>F)
C(income_group)	1.612089	3.0	37.449065	3.530131e-18
Residual	2.181074	152.0	NaN	NaN

	Income group	Region	Apples and products	Aquatic Animals, Others	Aquatic Plants	Bananas	Barley and products	Beans	Bovine Meat	Butter, Ghee	...	Soyabeans	Spices, Other	Sugar (Raw Equivalent)	Sunflowerseed Oil	Sweet potatoes	Sweeteners, Other	Tea (including mate)	Tomatoes and products	Vegetables, other	Wheat and products
Country
Afghanistan	1.0	5.0	3.0	0.1	-0.0	3.1	0.1	0.0	2.7	1.0	...	0.0	0.1	15.2	1.3	0.0	0.5	2.0	0.9	55.4	159.0
Angola	2.0	6.0	0.4	0.0	0.0	37.3	0.0	7.2	4.2	0.0	...	0.4	0.0	12.5	0.3	39.5	9.2	0.0	2.1	20.5	27.2
Albania	3.0	1.0	32.7	0.0	0.0	8.3	0.2	5.0	13.2	1.5	...	0.0	0.0	16.6	4.7	0.0	24.2	0.2	77.9	217.4	124.7

	Unnamed: 0	food_group	Zinc, Zn	Water	Vitamin K (phylloquinone)	Vitamin E (alpha-tocopherol)	Vitamin D3 (cholecalciferol)	Vitamin D2 (ergocalciferol)	Vitamin D (D2 + D3)	...	16:1 t	16:1 c	16:0	15:0	14:1	14:0	13:0	12:0	10:0
0	0	Dairy and Egg Products	0.825	63.550	0.6	0.18	0.5	0.0	0.5	...	0.0335	0.1210	1.9930	0.020	0.016	0.297	0.0000	0.093	0.076
1	1	Spices and Herbs	2.840	9.310	24.6	1.69	NaN	NaN	0.0	...	0.0000	0.0080	0.5740	0.000	0.000	0.020	0.0000	0.002	0.000
2	2	Baby Foods	0.490	83.200	5.1	0.56	0.1	0.0	0.0	...	0.0000	0.0010	0.4260	0.000	0.000	0.031	0.0000	0.007	0.001
3	3	Fats and Oils	0.000	0.070	42.2	5.00	0.7	0.0	0.0	...	0.0000	0.0685	7.9895	0.014	0.000	0.095	0.0005	0.000	0.000
4	4	Poultry Products	2.020	66.505	0.0	0.22	0.2	NaN	0.2	...	0.0040	0.1970	1.5200	0.006	0.008	0.056	NaN	0.010	0.000

	Zinc, Zn	Water	Vitamin K (phylloquinone)	Vitamin E, added	Vitamin E (alpha-tocopherol)	Vitamin D3 (cholecalciferol)	Vitamin D2 (ergocalciferol)	Vitamin D (D2 + D3)	Vitamin D	Vitamin C, total ascorbic acid	...	16:1 t	16:1 c	16:0	15:1	15:0	14:1	14:0	13:0	12:0	10:0
food_group
Dairy and Egg Products	0.825	63.550	0.60	0.0	0.180	0.50	0.00	0.50	20.0	0.0	...	0.0335	0.1210	1.9930	0.0	0.020	0.0160	0.2970	0.0000	0.0930	0.0760
Spices and Herbs	2.840	9.310	24.60	0.0	1.690	NaN	NaN	0.00	0.0	15.2	...	0.0000	0.0080	0.5740	0.0	0.000	0.0000	0.0200	0.0000	0.0020	0.0000
Baby Foods	0.490	83.200	5.10	0.0	0.560	0.10	0.00	0.00	2.0	7.9	...	0.0000	0.0010	0.4260	0.0	0.000	0.0000	0.0310	0.0000	0.0070	0.0010
Poultry Products	2.020	66.505	0.00	0.0	0.220	0.20	NaN	0.20	7.0	0.0	...	0.0040	0.1970	1.5200	0.0	0.006	0.0080	0.0560	NaN	0.0100	0.0000
Breakfast Cereals	4.310	97.495	4.55	0.0	2.430	NaN	NaN	3.55	141.0	9.0	...	NaN	NaN	2.6180	NaN	NaN	NaN	0.5175	NaN	1.3630	0.1230
Fruits and Fruit Juices	0.090	84.010	1.55	0.0	0.180	0.50	NaN	0.00	0.0	8.0	...	0.0000	0.0040	0.0160	0.0	0.001	0.0000	0.0000	NaN	0.0000	0.0000
Pork Products	2.275	65.125	0.00	0.0	0.220	0.70	0.00	0.70	27.0	0.0	...	0.0010	0.1080	1.8020	0.0	0.000	0.0000	0.1050	NaN	0.0050	0.0060
Vegetables and Vegetable Products	0.330	89.180	9.50	0.0	0.295	0.00	0.40	0.00	0.0	11.0	...	0.0000	0.0030	0.0420	0.0	0.000	0.0000	0.0010	0.0000	0.0000	0.0000
Beef Products	6.990	118.575	2.00	0.0	0.540	0.70	NaN	0.80	31.5	0.0	...	0.0350	0.9430	6.9660	0.0	0.057	0.0615	0.5695	NaN	0.0275	0.0285
Beverages	0.030	87.855	0.00	0.0	0.000	2.40	1.00	0.00	0.0	0.3	...	0.0000	0.0080	0.0000	0.0	0.000	0.0000	0.0000	0.0000	0.0000	0.0000
Finfish and Shellfish Products	0.660	72.970	0.10	0.0	0.890	2.65	0.00	2.80	113.0	0.0	...	0.0030	0.0475	0.4420	0.0	0.005	0.0010	0.0640	NaN	0.0000	0.0000
Legumes and Legume Products	1.090	69.000	3.00	0.0	0.255	NaN	1.05	0.00	0.0	0.0	...	0.0000	0.0160	0.1550	0.0	0.000	0.0000	0.0020	0.0000	0.0000	0.0000
Seeds, Nuts, and Oils	3.310	4.460	44.90	0.0	7.530	NaN	NaN	0.00	0.0	0.8	...	0.0000	0.1185	11.2925	0.0	0.014	0.0000	0.1250	0.0005	0.0000	0.0000

	Cereals	Roots & Tubers	Vegetables	Fruits & Plantains	Seeds, Nuts, and Oils	Starch and Sugars	Infant Food	Dairy and Egg Products	Finfish / Shellfish Products	Beef Products	Poultry	Legume and Legume Products	Spices & Herbs
Income group
High income	1244.0	463.0	1002.0	834.0	298.0	531.0	5.0	1591.0	287.0	250.0	316.0	46.0	16.0
Low income	1111.0	331.0	512.0	719.0	161.0	116.0	1.0	346.0	69.0	125.0	39.0	139.0	5.0
Lower middle income	1610.0	437.0	728.0	748.0	298.0	290.0	2.0	492.0	164.0	164.0	115.0	84.0	14.0
Upper middle income	1472.0	482.0	1135.0	1034.0	222.0	471.0	4.0	1116.0	159.0	200.0	281.0	57.0	24.0

	Zinc, Zn	Water	Vitamin K (phylloquinone)	Vitamin E (alpha-tocopherol)	Vitamin D3 (cholecalciferol)	Vitamin D2 (ergocalciferol)	Vitamin D (D2 + D3)	Vitamin D	Vitamin C, total ascorbic acid	...	16:1 t	16:1 c	16:0	15:1	15:0	14:1	14:0	13:0	12:0	10:0
Cereals	6939.10	156966.950	7325.5	3912.30	NaN	NaN	5715.5	227010.0	14490.0	...	NaN	NaN	4214.980	NaN	NaN	NaN	833.175	NaN	2194.430	198.030
Vegetables	240.24	64923.040	6916.0	214.76	0.0	291.2	0.0	0.0	8008.0	...	0.000	2.184	30.576	0.0	0.000	0.000	0.728	0.000	0.000	0.000
Fruits & Plantains	67.32	62839.480	1159.4	134.64	374.0	NaN	0.0	0.0	5984.0	...	0.000	2.992	11.968	0.0	0.748	0.000	0.000	NaN	0.000	0.000
Seeds, Nuts, and Oils	986.38	1329.080	13380.2	2243.94	NaN	NaN	0.0	0.0	238.4	...	0.000	35.313	3365.165	0.0	4.172	0.000	37.250	0.149	0.000	0.000
Starch and Sugars	8.70	25477.950	0.0	0.00	696.0	290.0	0.0	0.0	87.0	...	0.000	2.320	0.000	0.0	0.000	0.000	0.000	0.000	0.000	0.000
Infant Food	0.98	166.400	10.2	1.12	0.2	0.0	0.0	4.0	15.8	...	0.000	0.002	0.852	0.0	0.000	0.000	0.062	0.000	0.014	0.002
Dairy and Egg Products	405.90	31266.600	295.2	88.56	246.0	0.0	246.0	9840.0	0.0	...	16.482	59.532	980.556	0.0	9.840	7.872	146.124	0.000	45.756	37.392
Finfish / Shellfish Products	108.24	11967.080	16.4	145.96	434.6	0.0	459.2	18532.0	0.0	...	0.492	7.790	72.488	0.0	0.820	0.164	10.496	NaN	0.000	0.000
Beef Products	1146.36	19446.300	328.0	88.56	114.8	NaN	131.2	5166.0	0.0	...	5.740	154.652	1142.424	0.0	9.348	10.086	93.398	NaN	4.510	4.674
Poultry	232.30	7648.075	0.0	25.30	23.0	NaN	23.0	805.0	0.0	...	0.460	22.655	174.800	0.0	0.690	0.920	6.440	NaN	1.150	0.000
Legume and Legume Products	91.56	5796.000	252.0	21.42	NaN	88.2	0.0	0.0	0.0	...	0.000	1.344	13.020	0.0	0.000	0.000	0.168	0.000	0.000	0.000
Spices & Herbs	39.76	130.340	344.4	23.66	NaN	NaN	0.0	0.0	212.8	...	0.000	0.112	8.036	0.0	0.000	0.000	0.280	0.000	0.028	0.000

	mfad_values
Unnamed: 0
Cereals - Vegetables	3.095158
Cereals - Fruits & Plantains	3.190665
Cereals - Seeds, Nuts, and Oils	2.947283
Cereals - Starch and Sugars	3.282160
Cereals - Infant Food	3.310630
...	...
Beef Products - Spices & Herbs	0.225355
Poultry - Legume and Legume Products	0.091188
Poultry - Spices & Herbs	0.091808
Legume and Legume Products - Spices & Herbs	0.010756
Total	49.566934

	mfad_values	mfad_values	mfad_values	mfad_values
Unnamed: 0
Cereals - Vegetables	2.399558	3.479943	3.095158	2.608079
Cereals - Fruits & Plantains	2.415226	3.533978	3.190665	2.701032
Cereals - Seeds, Nuts, and Oils	2.234282	3.143595	2.947283	2.338134
Cereals - Starch and Sugars	2.492036	3.603758	3.282160	2.765629
Cereals - Infant Food	2.499084	3.621434	3.310630	2.797546

An Evaluation of National Food System According to the Sustainable Nutritional Security Criteria: The Analysis.¶

Metric 1: Food Nutrient Adequacy¶

Indicator 1: Non-Staple Food Energy¶

Indicator 2: Shannon Diversity¶

Indicator 3: Modified Functional Attibutite Diversity¶

Notes for the food condenser¶

Indicator 4: Nutrient Balance Score¶

5th Indicator: Population Share With Adequate Nutrients¶

Total Score: Metric 1.¶

Metric 2: Ecosystem Stability¶

1st Indicator: Ecosystem Status¶

2nd Indicator: Per Capita GHG Emissions¶

Indicator 3: Per Capita Net Freshwater Withdrawal¶

Indicator 4: Per Capita Non-Renewable Energy Use¶

Indicator 5: Per Capita Land Use¶

Total Metric Score: Metric 2¶

Metric 3: Food Affordability and Availability¶

Indicator 1: Food Affordability¶

Indicator 2: Food Availability¶

Indicator 3: Poverty Index¶

Indicator 4: Income Inequality¶

Total Metric Score: Metric 3¶

Metric 4: Sociocultural Wellbeing¶

Indicator 1: Gender Equity¶

Indicator 2: Instances of Child Labor¶

Indicator 3: Respect For Community Rights¶

Indicator 4: Animal Welfare¶

Total Metric Score¶

Metric 5: Resilience¶

Indicator 1: ND-GAIN¶

Indicator 2: Food Production Diversity¶

Total Metric Score¶

Metric 6: Food Safety¶

Metric 7: Food Waste¶

The Seven Metrics plotted¶

	mfad_low_income	mfad_lower_middle	mfad_upper_middle	mfad_high_income
Unnamed: 0
Beef Products - Spices & Herbs	0.146604	0.187997	0.225355	0.289671
Poultry - Legume and Legume Products	0.038729	0.023277	0.091188	0.108012
Poultry - Spices & Herbs	0.011695	0.034930	0.091808	0.110749
Legume and Legume Products - Spices & Herbs	0.047369	0.020370	0.010756	0.008009
Total	34.807447	51.482283	49.566934	47.364805

	Unnamed: 0	variable	value
0	Cereals - Vegetables	mfad_low_income	2.399558
1	Cereals - Fruits & Plantains	mfad_low_income	2.415226
2	Cereals - Seeds, Nuts, and Oils	mfad_low_income	2.234282
3	Cereals - Starch and Sugars	mfad_low_income	2.492036
4	Cereals - Infant Food	mfad_low_income	2.499084
...	...	...	...
259	Beef Products - Legume and Legume Products	mfad_high_income	0.286961
260	Beef Products - Spices & Herbs	mfad_high_income	0.289671
261	Poultry - Legume and Legume Products	mfad_high_income	0.108012
262	Poultry - Spices & Herbs	mfad_high_income	0.110749
263	Legume and Legume Products - Spices & Herbs	mfad_high_income	0.008009

	sum_sq	df	F	PR(>F)
C(variable)	2.572164	3.0	0.78914	0.500893
Residual	282.485905	260.0	NaN	NaN

	Total
mfad_lower_middle	51.482283
mfad_upper_middle	49.566934
mfad_high_income	47.364805
mfad_low_income	34.807447

	Entity	Code	Year	Median age - Sex: all - Age: all - Variant: estimates	Median age - Sex: all - Age: all - Variant: medium
0	Afghanistan	AFG	1950	18.4	NaN
1	Afghanistan	AFG	1951	18.4	NaN
2	Afghanistan	AFG	1952	18.4	NaN
3	Afghanistan	AFG	1953	18.3	NaN
4	Afghanistan	AFG	1954	18.3	NaN

	Entity	Code	Year	Median age - Sex: all - Age: all - Variant: estimates	Median age - Sex: all - Age: all - Variant: medium
69	Afghanistan	AFG	2019	16.3	NaN
220	Africa (UN)	NaN	2019	18.5	NaN
371	Albania	ALB	2019	36.5	NaN
522	Algeria	DZA	2019	27.4	NaN
673	American Samoa	ASM	2019	26.1	NaN

	Median age - Sex: all - Age: all - Variant: estimates
Entity
Afghanistan	16.3
Africa (UN)	18.5
Albania	36.5
Algeria	27.4
American Samoa	26.1

	Median age - Sex: all - Age: all - Variant: estimates
Income group
High income	38.585075
Low income	16.677273
Lower middle income	22.834783
Upper middle income	30.100000

	Median age - Sex: all - Age: all - Variant: estimates
Income group
High income	39.30
Low income	16.50
Lower middle income	22.15
Upper middle income	29.35

		units_in_one_gram	dri_low_income		dri_lower_middle		dri_upper_middle		dri_high_income
			male	female	male	female	male	female	male	female
Nutrient	Unit
Energy	kcal	7.716	3000.0	2200.0	2900.0	2200.0	2900.0	2200.0	2900.0	2200.0
Folate	micrograms	1000000.000	400.0	400.0	400.0	400.0	400.0	400.0	400.0	400.0
Niacin	milligrams	1000.000	16.0	14.0	16.0	14.0	16.0	14.0	16.0	14.0
Panthothenic Acid	milligrams	1000.000	5.0	5.0	5.0	5.0	5.0	5.0	5.0	5.0
Riboflavin	milligrams	1000.000	1.3	1.0	1.3	1.1	1.3	1.1	1.3	1.1
Thiamin	milligrams	1000.000	1.2	1.0	1.2	1.1	1.2	1.1	1.2	1.1
Vitamin A	micrograms	1000000.000	900.0	700.0	900.0	700.0	900.0	700.0	900.0	700.0
Vitamin B12	micrograms	1000000.000	2.4	2.4	2.4	2.4	2.4	2.4	2.4	2.4
Vitamin B6	milligrams	1000.000	1.3	1.2	1.3	1.3	1.3	1.3	1.3	1.3
Vitamin C	milligrams	1000.000	75.0	65.0	90.0	75.0	90.0	75.0	90.0	75.0
Vitamin D	micrograms	1000000.000	5.0	5.0	5.0	5.0	5.0	5.0	5.0	5.0
Vitamin E	milligrams	1000.000	15.0	15.0	15.0	15.0	15.0	15.0	15.0	15.0
Vitamin K	micrograms	1000000.000	120.0	90.0	120.0	90.0	120.0	90.0	120.0	90.0
Calcium	milligrams	1000.000	1300.0	1300.0	1000.0	1000.0	1000.0	1000.0	1000.0	1000.0
Copper	micrograms	1000000.000	890.0	890.0	900.0	900.0	900.0	900.0	900.0	900.0
Iron	milligrams	1000.000	11.0	15.0	8.0	18.0	8.0	18.0	8.0	18.0
Magnesium	millgrams	1000.000	410.0	360.0	420.0	320.0	420.0	320.0	420.0	320.0
Manganese	milligrams	1000.000	2.2	1.6	2.3	1.8	2.3	1.8	2.3	1.8
Phosphorus	milligrams	1000.000	1250.0	1250.0	700.0	700.0	700.0	700.0	700.0	700.0
Potassium	grams	1.000	4.7	4.7	4.7	4.7	4.7	4.7	4.7	4.7
Selenium	micrograms	1000000.000	55.0	55.0	55.0	55.0	55.0	55.0	55.0	55.0
Zinc	milligrams	1000.000	11.0	9.0	11.0	8.0	11.0	8.0	11.0	8.0
Alpha-Linolenic Acid	grams	1.000	1.6	1.6	1.6	1.6	1.6	1.6	1.6	1.6
Linoleic Acid	grams	1.000	16.0	16.0	17.0	17.0	17.0	17.0	17.0	17.0
Choline	milligrams	1000.000	550.0	400.0	550.0	425.0	550.0	425.0	550.0	425.0
Dietary Fiber	grams	1.000	38.0	26.0	38.0	25.0	38.0	25.0	38.0	25.0
Protein	gram	1.000	52.0	46.0	56.0	46.0	56.0	46.0	56.0	46.0
Water	grams	1.000	2.6	1.8	3.0	2.7	3.0	2.7	3.0	2.7